﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;
using System.Configuration;
using System.IO;
using System.ComponentModel;
using System.Globalization;
using System.Threading;

namespace SGT_ON
{
    /// <summary>
    /// Utilizado para las ALERTAS
    /// </summary>
    public partial class ONPresupuesto
    {
        /// <summary>
        /// Al actualizar el presupuesto, con este metodo se silencian las alarmas si estan activas.
        /// </summary>
        public void SilenciarAlertasSiEsNecesario()
        {
            // utiliza un hilo para detectar y silencial alertas activas.
            // 1 - Verifico si hay una alerta activa
            // 2 - Si no tiene alertas activas en el objeto, se busca si hay alertas activas en la tabla de alertas y se silencian.
            // Nota: el proceso se tiene que correr solo cuando se actualiza cualquier presupuesto.
            Thread _hilo = new Thread(this.SilenciarAlertas);
            _hilo.Start();
        }
        public void SilenciarAlertas()
        {
            if (AlertaVerificarSiHayAlgunaActiva == false)
                SilenciarTodasLasAlertasDelPresupuesto();
        }
        /// <summary>
        /// Silencia todas las alertas del presupuesto
        /// </summary>
        private void SilenciarTodasLasAlertasDelPresupuesto()
        {
            AlertaColeccion _alertas = Alerta.ObtenerPorIdReferenciaConTabla(this.ID + "Presupuesto");
            foreach (Alerta _alerta in _alertas)
            {
                _alerta.FechaSilenciada = DateTime.Now;
                _alerta.SilenciadaPor = this.UltimaModificacionPor + "(Automático)";
                _alerta.Actualizar();
            }
        }

        #region Búsqueda de alertas en el presupuesto.
        /// <summary>
        /// Verifica si hay alguna alerta activa para este presupuesto.
        /// NO busca las alertas en la tabla de alertas, si no que verifica el presupuesto si tiene alguna activa
        /// </summary>
        public bool AlertaVerificarSiHayAlgunaActiva
        {
            get
            {
                bool _resultado;

                _resultado = AlertaVerificarSihayEntregaProxima || AlertaVerificarSiHayDemoraEnElPago;

                return _resultado;
            }
        }
        /// <summary>
        /// Busca si hay alguna alerta por entrega próxima activa en el presupuesto actual
        /// </summary>
        private bool AlertaVerificarSihayEntregaProxima
        {
            get
            {
                // Verifico que:
                //      - El estado sea En Reparación
                //      - Falten menos dias que lo puesto en parametros
                //      - Tenga fecha de entrega activa
                if ((FechaEntregaEstimada.HasValue == true)
                    && (FechaEntregaEstimada.Value > Parametros.FechaMinima)
                    && (FechaEntregaEstimada.Value <= DateTime.Now.AddDays(Parametros.DiasAlertaDeEntrega))
                    && (Estado == enuEstados.Reparación.ToString()))
                    return true;
                else
                    return false;
            }
        }
        /// <summary>
        /// Verifico si:
        ///     - El estado es Facturado o Anotado
        ///     - La fecha de facturación mas la cantidad de dias de la aseguradora es mayor al dia de hoy
        /// </summary>
        private bool AlertaVerificarSiHayDemoraEnElPago
        {
            get
            {
                if(((Estado == enuEstados.Facturado.ToString())
                    || (Estado == enuEstados.Anotado.ToString()))
                    && (FechaFacturacion > Parametros.FechaMinima)
                    && (AseguradoraId > 0)
                    && (Aseguradora != null)
                    && (FechaFacturacion.AddDays(this.Aseguradora.DiasDuracionCuentaCorriente) <= DateTime.Now))
                    return true; // esta en alerta
                else
                    return false; // esta din alerta

            }
        }
        #endregion

    }
    /// <summary>
    /// Usada para los reportes
    /// </summary>
    public partial class ONPresupuesto
    {        
        /// <summary>
        /// Es la chaperia para el reporte de presupuestos.
        /// </summary>
        public string ChaperiaReporte
        {
            get
            { 
                decimal _resultado = ChaperiaOriginal;
                if (ChaperiaAutorizado != 0)
                    _resultado = ChaperiaAutorizado;

                if (DesarmadoAutorizado != 0)
                    _resultado = _resultado + DesarmadoAutorizado;
                else if (DesarmadoOriginal != 0)
                    _resultado = _resultado + DesarmadoOriginal;

                if (ArmadoAutorizado != 0)
                    _resultado = _resultado + ArmadoAutorizado;
                else if (ArmadoOriginal != 0)
                    _resultado = _resultado + ArmadoOriginal;

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string PinturaReporte
        {
            get
            {
                decimal _resultado = PinturaOriginal;
                if (PinturaAutorizado != 0)
                    _resultado = PinturaAutorizado;

                if (LustreAutorizado != 0)
                    _resultado = _resultado + LustreAutorizado;
                else if (LustreOriginal != 0)
                    _resultado = _resultado + LustreOriginal;

                if (EnceradoAutorizado != 0)
                    _resultado = _resultado + EnceradoAutorizado;
                else if (EnceradoOriginal != 0)
                    _resultado = _resultado + EnceradoOriginal;

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string RepuestosReporte
        {
            get
            {
                decimal _resultado = RepuestosOriginal;
                if (RepuestosAutorizado != 0)
                    _resultado = RepuestosAutorizado;

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string ExtrasReporte
        {
            get
            {
                decimal _resultado = decimal.Zero;
                if (ReparacionPlasticosAutorizado != 0)
                    _resultado = _resultado + ReparacionPlasticosAutorizado;
                else
                    _resultado = _resultado + ReparacionPlasticosOriginal;

                if (DespegadoYPegadoDeCristalesAutorizado != 0)
                    _resultado = _resultado + DespegadoYPegadoDeCristalesAutorizado;
                else
                    _resultado = _resultado + DespegadoYPegadoDeCristalesOriginal;

                if (MecanicaAutorizado != 0)
                    _resultado = _resultado + MecanicaAutorizado;
                else
                    _resultado = _resultado + MecanicaOriginal;

                if (MecanicaTrenDelanteroAutorizado != 0)
                    _resultado = _resultado + MecanicaTrenDelanteroAutorizado;
                else
                    _resultado = _resultado + MecanicaTrenDelanteroOriginal;

                if (AireAcondicionadoAutorizado != 0)
                    _resultado = _resultado + AireAcondicionadoAutorizado;
                else
                    _resultado = _resultado + AireAcondicionadoOriginal;

                if (TapiceriaAutorizado != 0)
                    _resultado = _resultado + TapiceriaAutorizado;
                else
                    _resultado = _resultado + TapiceriaOriginal;

                if (CerrajeriaAutorizado != 0)
                    _resultado = _resultado + CerrajeriaAutorizado;
                else
                    _resultado = _resultado + CerrajeriaOriginal;

                if (ElectricidadAutorizado != 0)
                    _resultado = _resultado + ElectricidadAutorizado;
                else
                    _resultado = _resultado + ElectricidadOriginal;

                if (ElectronicaAutorizado != 0)
                    _resultado = _resultado + ElectronicaAutorizado;
                else
                    _resultado = _resultado + ElectronicaOriginal;

                if (DespegadoYPegadoDeCristalesAutorizado != 0)
                    _resultado = _resultado + DespegadoYPegadoDeCristalesAutorizado;
                else
                    _resultado = _resultado + DespegadoYPegadoDeCristalesOriginal;

                if (ReparacionPlasticosAutorizado != 0)
                    _resultado = _resultado + ReparacionPlasticosAutorizado;
                else
                    _resultado = _resultado + ReparacionPlasticosOriginal;

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string TotalNetoReporte
        {
            get
            {
                decimal _chaperia, _pintura, _repuestos;
                decimal.TryParse(ChaperiaReporte, out _chaperia);
                decimal.TryParse(PinturaReporte, out _pintura);
                decimal.TryParse(RepuestosReporte, out _repuestos);

                decimal _resultado = _chaperia + _pintura + _repuestos; //franquicia agregar al lado de 

                /////////////////////////////////////////////////
                //Modificacion por franquicia:
                //Condicion: es para el reporte de presupuestos y se elige reporte x estado = "Cobrado" y hay que agregar los valores de la franquicia
                //que se facturaron como C, lo que se hace es agregar un presupuesto que tiene solo la franquicia y la misma es copiada en TotalNeto
                if((_resultado == decimal.Zero)
                    && (ExtrasReporte == "")
                    && (Estado == "Facturado")
                    && (TipoFacturacion == "C"))
                {
                    decimal _valor = FranquiciaOriginal;
                    if (FranquiciaAutorizado > decimal.Zero)
                        _valor = FranquiciaAutorizado;
                    _resultado = _valor;
                }
                //
                //////////////////////////////////////////////////////    


                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string TotalSinRepuestosReporte
        {
            get
            {
                decimal _chaperia, _pintura, _repuestos;
                decimal.TryParse(ChaperiaReporte, out _chaperia);
                decimal.TryParse(PinturaReporte, out _pintura);
                decimal.TryParse(RepuestosReporte, out _repuestos);

                decimal _resultado = _chaperia + _pintura;

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        public string FranquiciaReporte
        {
            get
            {
                decimal _resultado = FranquiciaOriginal;
                if (FranquiciaAutorizado > decimal.Zero)
                    _resultado = FranquiciaAutorizado;                

                if (_resultado == decimal.Zero)
                    return "";

                return _resultado.ToString(Parametros.FormatoDinero);
            }
        }
        
    }
    /// <summary>
    /// Propiedades y metodos derivados utilizados para presentación
    /// </summary>
    public partial class ONPresupuesto
    { 
        #region Parametros
        public static string _formatoDeDinero = "F"; // "0.0,0";
        #region Parametros de web.config.
        /// <summary>
        /// Determina el costo del paño.
        /// </summary>
        public  decimal CostoDePanoParametro
        {
            get
            {
                decimal _resultado = decimal.Zero;
                decimal.TryParse(Parametros.CostoPorPano, out _resultado);
                return _resultado;    
            }
            set
            {
                Parametros.CostoPorPano = value.ToString(_formatoDeDinero);
            }
        }
        /// <summary>
        /// Cantidad de dias para alarma de facturación.
        /// </summary>
        public int CantidadDeDiasAlarmaFacturacionPorDefecto
        {
            get
            {
                int _resultado = 0;
                int.TryParse(ConfigurationSettings.AppSettings["DiasPorDefectoParaAvisarCuandoSePasaAFacturado"], out _resultado);
                return _resultado;
            }
            set
            {
                ConfigurationSettings.AppSettings["DiasPorDefectoParaAvisarCuandoSePasaAFacturado"] = value.ToString();
            }
        }
        /// <summary>
        /// Determina el valor de IVA por defecto.
        /// </summary>
        public decimal IVAParametro
        {
            get
            {
                decimal _resultado = decimal.Zero;
                decimal.TryParse(ConfigurationSettings.AppSettings["IVAPorDefecto"], out _resultado);
                return _resultado;
            }
            set
            {
                ConfigurationSettings.AppSettings["IVAPorDefecto"] = value.ToString(_formatoDeDinero);
            }
        }
        #endregion
        #endregion

        #region Propiedades derivadas
        public DateTime? FechaProximaAlarma
        {
            get
            {
                return Alarmas.FechaHoraProximaAlarma;
            }
        }
        
        public string MotivoProximaAlarma
        {
            get
            {
                return Alarmas.ProximaAlarmaMotivo;
            }
        }

        public string TotalOriginalComoPalabras
        {
            get
            {
                return Utilidades.NumberToWords(TotalOriginal);
            }
        }

        public Decimal SubtotalAutorizado
        {
            get
            {
                decimal _resultado = decimal.Zero;

                _resultado = ChaperiaAutorizado + PinturaAutorizado + LustreAutorizado + EnceradoAutorizado + ArmadoAutorizado + DesarmadoAutorizado + ReparacionPlasticosAutorizado + DespegadoYPegadoDeCristalesAutorizado + MecanicaAutorizado + MecanicaTrenDelanteroAutorizado + AireAcondicionadoAutorizado + TapiceriaAutorizado + CerrajeriaAutorizado + ElectricidadAutorizado + RepuestosAutorizado + ElectronicaAutorizado;

                return _resultado;
            }
        }
        public Decimal SubtotalOriginal
        {
            get
            {
                decimal _resultado = decimal.Zero;

                _resultado = ChaperiaOriginal + PinturaOriginal + LustreOriginal + EnceradoOriginal + ArmadoOriginal + DesarmadoOriginal + ReparacionPlasticosOriginal + DespegadoYPegadoDeCristalesOriginal + MecanicaOriginal + MecanicaTrenDelanteroOriginal + AireAcondicionadoOriginal + TapiceriaOriginal + CerrajeriaOriginal + ElectricidadOriginal + RepuestosOriginal + ElectronicaOriginal;

                return _resultado;
            }
        }


        public ONElementoColeccion ElementosAReemplazar
        {
            get
            {
                ONElementoColeccion _resultado = new ONElementoColeccion();
                foreach (ONElemento _elemento in this.TodosLosElementos)
                {
                    if (_elemento.Reponer == true)
                        _resultado.Add(_elemento);
                }
                return _resultado;
            }
        }
        public ONElementoColeccion ElementosAReparar
        {
            get
            {
                ONElementoColeccion _resultado = new ONElementoColeccion();
                foreach (ONElemento _elemento in this.TodosLosElementos)
                {
                    if (_elemento.Reacondicionar == true)
                        _resultado.Add(_elemento);
                }
                return _resultado;
            }
        }
        public ONElementoColeccion ElementosSacarColocar
        {
            get
            {
                ONElementoColeccion _resultado = new ONElementoColeccion();
                foreach (ONElemento _elemento in this.TodosLosElementos)
                {
                    if (_elemento.SacarColocar == true)
                        _resultado.Add(_elemento);
                }
                return _resultado;
            }
        }

        public decimal SubTotalOriginal
        {
            get
            {
                decimal _resultado = ChaperiaOriginal + PinturaOriginal + LustreOriginal + EnceradoOriginal + ArmadoOriginal + DesarmadoOriginal + ReparacionPlasticosOriginal + DespegadoYPegadoDeCristalesOriginal + MecanicaOriginal + MecanicaTrenDelanteroOriginal + AireAcondicionadoOriginal + TapiceriaOriginal + CerrajeriaOriginal + ElectricidadOriginal + RepuestosOriginal + ElectronicaOriginal + OtrosOriginal;
                _resultado = ONPresupuesto.CalcularSubTotalConFranquicia(_resultado, FranquiciaOriginal, TipoFacturacion);
                return _resultado;
            }
        }
        public decimal SubTotalAutorizado
        {
            get
            {
                decimal _resultado = ChaperiaAutorizado + PinturaAutorizado + LustreAutorizado + EnceradoAutorizado + ArmadoAutorizado + DesarmadoAutorizado + ReparacionPlasticosAutorizado + DespegadoYPegadoDeCristalesAutorizado + MecanicaAutorizado + MecanicaTrenDelanteroAutorizado + AireAcondicionadoAutorizado + TapiceriaAutorizado + CerrajeriaAutorizado + ElectricidadAutorizado + RepuestosAutorizado + ElectronicaAutorizado + OtrosAutorizado;
                _resultado = ONPresupuesto.CalcularSubTotalConFranquicia(_resultado, FranquiciaAutorizado, TipoFacturacion);
                return _resultado;
            }
        }

        public decimal IVAAutorizado
        {
            get
            {
                if (IVA <= 0)
                    return 0;
                decimal _iva = (IVA / 100);
                return SubtotalAutorizado * _iva;
            }
        }
        public decimal IVAOriginal
        {
            get
            {
                if (IVA <= 0)
                    return 0;
                decimal _iva = (IVA / 100);
                return SubtotalOriginal * _iva;
            }
        }

        public decimal CantidadDePanos
        {
            get
            {
                decimal _resultado = decimal.Zero;
                foreach (ONElemento _elemeto in TodosLosElementos)
                {
                    _resultado = _resultado + _elemeto.PintarCantidad;
                }
                return _resultado;
            }
        }

        public int CantidadDeFotosAsociadas
        {
            get
            {
                return ONFotoColeccion.ObtenerCantidadDeFotos(this.ID);
            }
        }

        public bool PresupuestoOriginalIdTieneAsignado
        {
            get
            {
                if (PresupuestoOriginalId > 0)
                    return true;
                else
                    return false;
            }
        }

        /// <summary>
        /// Nombre de la aseguradora asociada
        /// </summary>
        public string AseguradoraRazonSocial
        {
            get
            {
                if (Aseguradora == null)
                    return "";
                return Aseguradora.RazonSocial;
            }
        }
        /// <summary>
        /// Indica si el presupuesto tiene un responsable asignado
        /// </summary>
        public bool TieneResponsable
        {
            get
            {
                if (UsuarioResponsableId <= 0)
                    return false;
                else
                    return true;
            }
        }
        /// <summary>
        /// Devuelve el usuario responsable del presupuesto
        /// </summary>
        public string UsuarioResponsableNombre
        {
            get
            {
                if (TieneResponsable == false)
                    return "";
                else
                    return UsuarioResponsable.ApellidoYNombre;
            }
        }
        /// <summary>
        /// Indica si se puede exportar la Orden de Trabajo
        /// </summary>
        public bool PuedeExportarOT
        {
            get
            {
                if (Estado == enuEstados.Reparación.ToString())
                    return true;
                else if (Estado == enuEstados.Anotado.ToString())
                    return true;
                else if (Estado == enuEstados.Cancelado.ToString())
                    return true;
                else if (Estado == enuEstados.Facturado.ToString())
                    return true;
                else if (Estado == enuEstados.Cobrado.ToString())
                    return true;
                else if (Estado == enuEstados.Presupuesto.ToString())
                    return true;
                else if (Estado == enuEstados.Borrador.ToString())
                    return true;
                else if (Estado == enuEstados.Cerrado.ToString())
                    return true;
                else
                    return false;

            }
        }

        
        #endregion

        #region Propiedades como string
        public string CantidadDePanosString
        {
            get 
            {
                if (CantidadDePanos == decimal.Zero)
                    return "";
                return CantidadDePanos.ToString(_formatoDeDinero);
            }
        }

        public string IVAAutorizadoString
        {
            get
            {
                if (IVAAutorizado <= decimal.Zero)
                    return "";
                return IVAAutorizado.ToString(_formatoDeDinero);
            }
        }
        public string IVAOriginalString
        {
            get
            {
                if (IVAOriginal <= decimal.Zero)
                    return "";
                return IVAOriginal.ToString(_formatoDeDinero);
            }
        }

        public string SubTotalOriginalString
        {
            get
            {
                if (SubtotalOriginal == decimal.Zero)
                    return "";
                return SubTotalOriginal.ToString(_formatoDeDinero);
            }
        }
        public string SubTotalAutorizadoString
        {
            get
            {
                if (SubtotalAutorizado == decimal.Zero)
                    return "";
                return SubTotalAutorizado.ToString(_formatoDeDinero);
            }
        }

        public string FechaProximaAlarmaString
        {
            get
            {
                if (FechaProximaAlarma.HasValue == false)
                    return "";
                else
                    return FechaProximaAlarma.Value.ToString("dd/MM/yyyy");
            }
        }
        public string ApellidoYNombre
        {
            get { return Apellido + ", " + Nombre; }
        }
        public string FechaPresupuestoString
        {
            get
            {
                if (FechaPresupuesto == DateTime.MinValue)
                    return "";
                return _fechaPresupuesto.ToString("dd/MM/yyyy");
            }
            set
            {
                try
                {
                    if (value != "")
                        FechaPresupuesto = DateTime.Parse(value);
                }
                catch
                {
                    throw new ArgumentException("La fecha de presupuesto no es válida");
                }
            }
        }
        public string FechaEntregaEstimadaString
        {
            get
            {
                if ((FechaEntregaEstimada.HasValue == false)
                    || (FechaPresupuesto <= Parametros.FechaMinima))
                    return "";
                return FechaEntregaEstimada.Value.ToString("dd/MM/yyyy");
            }
            set
            {
                try
                {
                    if (value != "")
                        FechaEntregaEstimada = DateTime.Parse(value);
                }
                catch
                {
                    throw new ArgumentException("La fecha de presupuesto no es válida");
                }
            }
        }        
        public string CostoDePanoString
        {
            get
            {
                if (CostoDePano == decimal.Zero)
                    return "";
                else
                    return CostoDePano.ToString("0");
            }
            set
            {
                try
                {
                    if (value != "")
                        CostoDePano = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El costo de pano no es válido");
                }
            }
        }
        
        public string FechaHoraUltimaActualizacionString
        {
            get
            {
                return FechaHoraUltimaActualizacion.ToString("dd/MM/YYYY HH:mm");
            }            
        }
        public string FechaHoraCreacionString
        {
            get
            {
                return FechaHoraCreacion.ToString("dd/MM/yyyy");
            }
        }
        public string AireAcondicionadoAutorizadoString
        {
            get
            {
                if (AireAcondicionadoAutorizado == decimal.Zero)
                    return "";
                else
                    return AireAcondicionadoAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        AireAcondicionadoAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de aire acondicionado autorizado no es válido");
                }
            }
        }
        public string AireAcondicionadoOriginalString
        {
            get
            {
                if (AireAcondicionadoOriginal == decimal.Zero)
                    return "";
                else
                    return AireAcondicionadoOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        AireAcondicionadoOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de aire acondicionado original no es válido");
                }
            }
        }
        public string CerrajeriaAutorizadoString
        {
            get
            {
                if (CerrajeriaAutorizado == decimal.Zero)
                    return "";
                else
                    return CerrajeriaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        CerrajeriaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de cerrajería autorizado no es válido");
                }
            }
        }
        public string CerrajeriaOriginalString
        {
            get
            {
                if (CerrajeriaOriginal == decimal.Zero)
                    return "";
                else
                    return CerrajeriaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        CerrajeriaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de cerrajería original no es válido");
                }
            }
        }
        public string ChaperiaAutorizadoString
        {
            get
            {
                if (ChaperiaAutorizado == decimal.Zero)
                    return "";
                else
                    return ChaperiaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ChaperiaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de chaperia autorizado no es válido");
                }
            }
        }
        public string ChaperiaOriginalString
        {
            get
            {
                if (ChaperiaOriginal == decimal.Zero)
                    return "";
                else
                    return ChaperiaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ChaperiaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de chaperia original no es válido");
                }
            }
        }
        public string DespegadoYPegadoDeCristalesOriginalString
        {
            get
            {
                if (DespegadoYPegadoDeCristalesOriginal == decimal.Zero)
                    return "";
                else
                    return DespegadoYPegadoDeCristalesOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DespegadoYPegadoDeCristalesOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de despegado y pegado de cristales original no es válido");
                }
            }
        }
        public string DespegadoYPegadoDeCristalesAutorizadoString
        {
            get
            {
                if (DespegadoYPegadoDeCristalesAutorizado == decimal.Zero)
                    return "";
                else
                    return DespegadoYPegadoDeCristalesAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DespegadoYPegadoDeCristalesAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de despegado y pegado de cristales autorizado no es válido");
                }
            }
        }
        public string ElectricidadOriginalString
        {
            get
            {
                if (ElectricidadOriginal == decimal.Zero)
                    return "";
                else
                    return ElectricidadOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectricidadOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electricidad original no es válido");
                }
            }
        }
        public string ElectricidadAutorizadoString
        {
            get
            {
                if (ElectricidadAutorizado == decimal.Zero)
                    return "";
                else
                    return ElectricidadAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectricidadAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electricidad autorizado no es válido");
                }
            }
        }
        public string EnceradoAutorizadoString
        {
            get
            {
                if (EnceradoAutorizado == decimal.Zero)
                    return "";
                else
                    return EnceradoAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        EnceradoAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de encerado autorizado no es válido");
                }
            }
        }
        public string EnceradoOriginalString
        {
            get
            {
                if (EnceradoOriginal == decimal.Zero)
                    return "";
                else
                    return EnceradoOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        EnceradoOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de encerado original no es válido");
                }
            }
        }
        public string MecanicaAutorizadoString
        {
            get
            {
                if (MecanicaAutorizado == decimal.Zero)
                    return "";
                else
                    return MecanicaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de mecánica autorizado no es válido");
                }
            }
        }
        public string MecanicaOriginalString
        {
            get
            {
                if (MecanicaOriginal == decimal.Zero)
                    return "";
                else
                    return MecanicaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de mecánica original no es válido");
                }
            }
        }
        public string MecanicaTrenDelanteroAutorizadoString
        {
            get
            {
                if (MecanicaTrenDelanteroAutorizado == decimal.Zero)
                    return "";
                else
                    return MecanicaTrenDelanteroAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaTrenDelanteroAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de mecánica tren delantero autorizado no es válido");
                }
            }
        }
        public string MecanicaTrenDelanteroOriginalString
        {
            get
            {
                if (MecanicaTrenDelanteroOriginal == decimal.Zero)
                    return "";
                else
                    return MecanicaTrenDelanteroOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaTrenDelanteroOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de mecanica tren delantero original no es válido");
                }
            }
        }
        public string PinturaOriginalString
        {
            get
            {
                if (PinturaOriginal == decimal.Zero)
                    return "";
                else
                    return PinturaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        PinturaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de pintura original no es válido");
                }
            }
        }
        public string PinturaAutorizadoString
        {
            get
            {
                if (PinturaAutorizado == decimal.Zero)
                    return "";
                else
                    return PinturaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        PinturaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de pintura autorizado no es válido");
                }
            }
        }
        public string ReparacionPlasticosOriginalString
        {
            get
            {
                if (ReparacionPlasticosOriginal == decimal.Zero)
                    return "";
                else
                    return ReparacionPlasticosOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ReparacionPlasticosOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de reparación de plasticos original no es válido");
                }
            }
        }
        public string ReparacionPlasticosAutorizadoString
        {
            get
            {
                if (ReparacionPlasticosAutorizado == decimal.Zero)
                    return "";
                else
                    return ReparacionPlasticosAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ReparacionPlasticosAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de reparación de plasticos autorizado no es válido");
                }
            }
        }
        public string RepuestosOriginalString
        {
            get
            {
                if (RepuestosOriginal == decimal.Zero)
                    return "";
                else
                    return RepuestosOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        RepuestosOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de repuestos original no es válido");
                }
            }
        }
        public string RepuestosAutorizadoString
        {
            get
            {
                if (RepuestosAutorizado == decimal.Zero)
                    return "";
                else
                    return RepuestosAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        RepuestosAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de repuestos autorizado no es válido");
                }
            }
        }
        public string TapiceriaOriginalString
        {
            get
            {
                if (TapiceriaOriginal == decimal.Zero)
                    return "";
                else
                    return TapiceriaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        TapiceriaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de tapicería original no es válido");
                }
            }
        }
        public string TapiceriaAutorizadoString
        {
            get
            {
                if (TapiceriaAutorizado == decimal.Zero)
                    return "";
                else
                    return TapiceriaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        TapiceriaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de tapicería autorizado no es válido");
                }
            }
        }
        public string LustreOriginalString
        {
            get
            {
                if (LustreOriginal == decimal.Zero)
                    return "";
                else
                    return LustreOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        LustreOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de lustre original no es válido");
                }
            }
        }
        public string LustreAutorizadoString
        {
            get
            {
                if (LustreAutorizado == decimal.Zero)
                    return "";
                else
                    return LustreAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        LustreAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de lustre autorizado no es válido");
                }
            }
        }
        public string ArmadoOriginalString
        {
            get
            {
                if (ArmadoOriginal == decimal.Zero)
                    return "";
                else
                    return ArmadoOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ArmadoOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de armado original no es válido");
                }
            }
        }
        public string ArmadoAutorizadoString
        {
            get
            {
                if (ArmadoAutorizado == decimal.Zero)
                    return "";
                else
                    return ArmadoAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ArmadoAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de armado autorizado no es válido");
                }
            }
        }
        public string DesarmadoOriginalString
        {
            get
            {
                if (DesarmadoOriginal == decimal.Zero)
                    return "";
                else
                    return DesarmadoOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DesarmadoOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de desarmado original no es válido");
                }
            }
        }
        public string DesarmadoAutorizadoString
        {
            get
            {
                if (DesarmadoAutorizado == decimal.Zero)
                    return "";
                else
                    return DesarmadoAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DesarmadoAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de desarmado autorizado no es válido");
                }
            }
        }
        public string ElectronicaOriginalString
        {
            get
            {
                if (ElectronicaOriginal == decimal.Zero)
                    return "";
                else
                    return ElectronicaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectronicaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electrónica original no es válido");
                }
            }
        }
        public string ElectronicaAutorizadoString
        {
            get
            {
                if (ElectronicaAutorizado == decimal.Zero)
                    return "";
                else
                    return ElectronicaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectronicaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electrónica autorizado no es válido");
                }
            }
        }
        public string TotalOriginalString
        {
            get
            {
                if (TotalOriginal == decimal.Zero)
                    return "";
                else
                    return TotalOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        TotalOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electrónica original no es válido");
                }
            }
        }
        public string TotalAutorizadoString
        {
            get
            {
                if (TotalAutorizado == decimal.Zero)
                    return "";
                else
                    return TotalAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        TotalAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de electrónica autorizado no es válido");
                }
            }
        }
        public string IVAString
        {
            get
            {
                if (IVA == decimal.Zero)
                    return "";
                else
                {
                    if (IVA == 21)
                        return "21";
                    if (IVA == decimal.Parse("10,5"))
                        return "10,5";
                    return IVA.ToString();
                }
            }
            set
            {
                try
                {
                    if (value != "")
                        IVA = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de IVA no es válido");
                }
            }
        }
        public string ReparacionPlasticosPorcentajeString
        {
            get
            {
                if (ReparacionPlasticosPorcentaje == decimal.Zero)
                    return "";
                else
                    return ReparacionPlasticosPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        ReparacionPlasticosPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de IVA Autorizado no es válido");
                }
            }
        }
        public string DespegadoYPegadoDeCristalesPorcentajeString
        {
            get
            {
                if (DespegadoYPegadoDeCristalesPorcentaje == decimal.Zero)
                    return "";
                else
                    return DespegadoYPegadoDeCristalesPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        DespegadoYPegadoDeCristalesPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de DespegadoYPegadoDeCristalesPorcentaje Autorizado no es válido");
                }
            }
        }
        public string MecanicaPorcentajeString
        {
            get
            {
                if (MecanicaPorcentaje == decimal.Zero)
                    return "";
                else
                    return MecanicaPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de MecanicaPorcentaje no es válido");
                }
            }
        }
        public string MecanicaTrenDelanteroPorcentajeString
        {
            get
            {
                if (MecanicaTrenDelanteroPorcentaje == decimal.Zero)
                    return "";
                else
                    return MecanicaTrenDelanteroPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        MecanicaTrenDelanteroPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de MecanicaTrenDelanteroPorcentaje no es válido");
                }
            }
        }
        public string AireAcondicionadoPorcentajeString
        {
            get
            {
                if (AireAcondicionadoPorcentaje == decimal.Zero)
                    return "";
                else
                    return AireAcondicionadoPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        AireAcondicionadoPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de AireAcondicionadoPorcentaje no es válido");
                }
            }
        }
        public string TapiceriaPorcentajeString
        {
            get
            {
                if (TapiceriaPorcentaje == decimal.Zero)
                    return "";
                else
                    return TapiceriaPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        TapiceriaPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de TapiceriaPorcentaje no es válido");
                }
            }
        }
        public string CerrajeriaPorcentajeString
        {
            get
            {
                if (CerrajeriaPorcentaje == decimal.Zero)
                    return "";
                else
                    return CerrajeriaPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        CerrajeriaPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de CerrajeriaPorcentaje no es válido");
                }
            }
        }
        public string ElectricidadPorcentajeString
        {
            get
            {
                if (ElectricidadPorcentaje == decimal.Zero)
                    return "";
                else
                    return ElectricidadPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectricidadPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de ElectricidadPorcentaje no es válido");
                }
            }
        }
        public string RepuestosPorcentajeString
        {
            get
            {
                if (RepuestosPorcentaje == decimal.Zero)
                    return "";
                else
                    return RepuestosPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        RepuestosPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de RepuestosPorcentaje no es válido");
                }
            }
        }
        public string ElectronicaPorcentajeString
        {
            get
            {
                if (ElectronicaPorcentaje == decimal.Zero)
                    return "";
                else
                    return ElectronicaPorcentaje.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        ElectronicaPorcentaje = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de ElectronicaPorcentaje no es válido");
                }
            }
        }
        public string FechaFacturacionString
        {
            get
            {
                return FechaFacturacion.ToString("dd/MM/yyyy HH:mm");
            }
            set
            {
                try
                {
                    if (value != "")
                        FechaFacturacion = DateTime.Parse(value);
                }
                catch
                {
                    throw new ArgumentException("La fecha FechaFacturacion no es válida");
                }
            }
        }
        public string IVAPresupuestoString
        {
            get
            {
                if (IVAPresupuesto == decimal.Zero)
                    return "";
                else
                    return IVAPresupuesto.ToString();
            }
            set
            {
                try
                {
                    if (value != "")
                        IVAPresupuesto = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de IVAPresupuesto no es válido");
                }
            }
        }
        public string SubtotalAutorizadoString
        {
            get
            {
                if (SubtotalAutorizado == decimal.Zero)
                    return "";
                else
                    return SubtotalAutorizado.ToString(_formatoDeDinero);
            }
        }
        public string SubtotalOriginalString
        {
            get
            {
                if (SubtotalOriginal == decimal.Zero)
                    return "";
                else
                    return SubtotalOriginal.ToString(_formatoDeDinero);
            }
        }
        public string DespegadoYPegadoDeMoldurasEInsigniasOriginalString
        {
            get
            {
                if (DespegadoYPegadoDeMoldurasEInsigniasOriginal == decimal.Zero)
                    return "";
                else
                    return DespegadoYPegadoDeMoldurasEInsigniasOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DespegadoYPegadoDeMoldurasEInsigniasOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de Despegado y pegado de molduras e insignias original no es válido");
                }
            }
        }
        public string DespegadoYPegadoDeMoldurasEInsigniasAutorizadoString
        {
            get
            {
                if (DespegadoYPegadoDeMoldurasEInsigniasAutorizado == decimal.Zero)
                    return "";
                else
                    return DespegadoYPegadoDeMoldurasEInsigniasAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        DespegadoYPegadoDeMoldurasEInsigniasAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de despegado y pegado de molduras e insignias autorizado no es válido");
                }
            }
        }
        public string OtrosOriginalString
        {
            get
            {
                if (OtrosOriginal == decimal.Zero)
                    return "";
                else
                    return OtrosOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        OtrosOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de Otros original no es válido");
                }
            }
        }
        public string OtrosAutorizadoString
        {
            get
            {
                if (OtrosAutorizado == decimal.Zero)
                    return "";
                else
                    return OtrosAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        OtrosAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de Otros autorizado no es válido");
                }
            }
        }
        public string FechaIngresoString
        {
            get
            {
                if ((FechaIngreso.HasValue == false)
                    || (FechaIngreso <= Parametros.FechaMinima))
                    return "";
                return FechaIngreso.Value.ToString("dd/MM/yyyy");
            }
            set
            {
                try
                {
                    if (value != "")
                        FechaIngreso = DateTime.Parse(value);
                }
                catch
                {
                    throw new ArgumentException("La fecha de ingreso no es válida");
                }
            }
        }
        public string FranquiciaAutorizadoString
        {
            get
            {
                if (FranquiciaAutorizado == decimal.Zero)
                    return "";
                else
                    return FranquiciaAutorizado.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        FranquiciaAutorizado = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de Franquicia Autorizado no es válido");
                }
            }
        }
        public string FranquiciaOriginalString
        {
            get
            {
                if (FranquiciaOriginal == decimal.Zero)
                    return "";
                else
                    return FranquiciaOriginal.ToString(_formatoDeDinero);
            }
            set
            {
                try
                {
                    if (value != "")
                        FranquiciaOriginal = Utilidades.ConvertirADecimal(value);
                }
                catch
                {
                    throw new ArgumentException("El valor de Franquicia Original no es válido");
                }
            }
        }
        public string FechaEntregaEstimadaConDia
        {
            get
            {
                if(FechaEntregaEstimada == Parametros.FechaMinima)
                    return "";

                CultureInfo ci = new CultureInfo("Es-Es");
                 string _dia = (ci.DateTimeFormat.GetDayName(FechaEntregaEstimada.Value.DayOfWeek)) + " " + FechaEntregaEstimadaString;
                _dia = _dia.Substring(0, 1).ToUpper() + _dia.Substring(1);

                return _dia;
            }
        }

        //public string FechaEntregaEstimadaString
        //{
        //    get
        //    {
        //        if (FechaEntregaEstimada <= Parametros.FechaMinima)
        //            return "";
        //        return FechaEntregaEstimada.ToString("dd/MM/yyyy");
        //    }
        //    set
        //    {
        //        try
        //        {
        //            if ((value == null)
        //                || (value == ""))
        //                FechaEntregaEstimada = Parametros.FechaMinima;
        //            else
        //                FechaEntregaEstimada = DateTime.Parse(value);
        //        }
        //        catch
        //        {
        //            throw new ArgumentException("La fecha FechaEntregaEstimada no es válida");
        //        }
        //    }
        //}
        //public string FechaEntregaRealString
        //{
        //    get
        //    {
        //        return FechaEntregaReal.ToString("dd/MM/yyyy");
        //    }
        //    set
        //    {
        //        try
        //        {
        //            if (value != "")

        //                FechaEntregaReal = DateTime.Parse(value);
        //        }
        //        catch
        //        {
        //            throw new ArgumentException("La fecha FechaEntregaReal no es válida");
        //        }
        //    }
        //}
        #endregion
    }

    /// <summary>
    /// Objeto de negocio base con toda la lógica del sistema.
    /// </summary>
    [Serializable]
    [System.ComponentModel.DataObject]
    public partial class ONPresupuesto
    {
        #region Banderas internas
        #endregion

        #region Atributos
        protected int _id;
        protected string _nombre;
        protected string _apellido;
        protected string _CUIT;
        protected string _celularTelefono;
        protected DateTime _fechaPresupuesto;
        protected string _modelo;
        protected string _marca;
        protected string _patente;
        //protected string _aseguradora;
        protected string _inspector;
        protected string _proveedorDeRepuestos;
        protected string _tipologiaDeAutoNombre;
        protected decimal _tipologiaDeAutoCoeficiente;
        protected decimal _costoDePano;
        protected string _estado;
        protected DateTime _fechaHoraUltimaActualizacion;
        protected DateTime _fechaHoraCreacion;
        protected string _Observaciones;
        protected decimal _aireAcondicionadoAutorizado;
        protected decimal _aireAcondicionadoOriginal;
        protected decimal _cerrajeriaAutorizado;
        protected decimal _cerrajeriaOriginal;
        protected decimal _chaperiaAutorizado;
        protected decimal _chaperiaOriginal;
        protected decimal _despegadoYPegadoDeCristalesOriginal;
        protected decimal _despegadoYPegadoDeCristalesAutorizado;
        protected decimal _electricidadOriginal;
        protected decimal _electricidadAutorizado;
        protected decimal _enceradoAutorizado;
        protected decimal _enceradoOriginal;
        protected decimal _mecanicaAutorizado;
        protected decimal _mecanicaOriginal;
        protected decimal _mecanicaTrenDelanteroAutorizado;
        protected decimal _mecanicaTrenDelanteroOriginal;
        protected decimal _pinturaOriginal;
        protected decimal _pinturaAutorizado;
        protected decimal _reparacionPlasticosOriginal;
        protected decimal _reparacionPlasticosAutorizado;
        protected decimal _repuestosOriginal;
        protected decimal _repuestosAutorizado;
        protected decimal _tapiceriaOriginal;
        protected decimal _tapiceriaAutorizado;
        protected decimal _lustreOriginal;
        protected decimal _lustreAutorizado;
        protected decimal _armadoOriginal;
        protected decimal _armadoAutorizado;
        protected decimal _desarmadoOriginal;
        protected decimal _desarmadoAutorizado;
        protected decimal _electronicaOriginal;
        protected decimal _electronicaAutorizado;
        protected string _numeroDeChasis;
        protected decimal _totalAutorizado;
        protected decimal _totalOriginal;
        protected decimal _IVA;
        protected decimal _ReparacionPlasticosPorcentaje;
        protected decimal _DespegadoYPegadoDeCristalesPorcentaje;
        protected decimal _MecanicaPorcentaje;
        protected decimal _MecanicaTrenDelanteroPorcentaje;
        protected decimal _AireAcondicionadoPorcentaje;
        protected decimal _TapiceriaPorcentaje;
        protected decimal _CerrajeriaPorcentaje;
        protected decimal _ElectricidadPorcentaje;
        protected decimal _RepuestosPorcentaje;
        protected decimal _ElectronicaPorcentaje;
        protected decimal _IVAPresupuesto;
        protected DateTime _FechaFacturacion;
        protected DateTime? _FechaEntregaEstimada;
        protected DateTime? _FechaEntregaReal;
        protected string _NumeroDeSiniestro;
        protected int _EmpleadoChaperiaId;
        protected int _EmpleadoPinturaId;
        protected bool _RepuestosACargoDeLaCompaniaDeSeguros;
        protected decimal _DespegadoYPegadoDeMoldurasEInsigniasOriginal;
        protected decimal _DespegadoYPegadoDeMoldurasEInsigniasAutorizado;
        protected decimal _OtrosOriginal;
        protected decimal _OtrosAutorizado;
        protected DateTime? _FechaIngreso;
        protected string _CreadoPor;
        protected string _UltimaModificacionPor;
        protected string _AnoVehiculo;
        protected string _FacturaRepuestos;
        protected string _FacturaDeVenta;        
        protected string _TipoFacturacion;
        protected decimal _FranquiciaOriginal;
        protected decimal _FranquiciaAutorizado;
        protected int _PresupuestoOriginalId;
        protected string _NumeroDeFactura;
        protected string _NumeroReciboTransferencia;
        protected int _AseguradoraId;
        protected int _UsuarioResponsableId;

        //objetos
        protected ONElementoColeccion _TodosLosElementos;
        private SGT_ON.Aseguradora _Aseguradora;
        protected ONEmpleado _UsuarioResponsable;

        

        /// <summary>
        /// Objetos
        /// </summary>
        ONPresupuestoAlarmaColeccion _alarmas;
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public string Nombre
        {
            get
            {
                if (_nombre == "")
                    return _nombre;
                else
                    return Utilidades.ConvertFirstLetterToUpper(_nombre);
            }
            set
            {
                if (value == "")
                    _nombre = value;
                else
                    _nombre = Utilidades.ConvertFirstLetterToUpper(value);
            }
        }
        public string Apellido
        {
            get
            {
                if (_apellido == "")
                    return _apellido;
                else
                    return Utilidades.ConvertFirstLetterToUpper(_apellido);
            }
            set
            {
                if (value == "")
                    _apellido = value;
                else
                    _apellido = Utilidades.ConvertFirstLetterToUpper(value);
            }
        }
        public string CUIT
        {
            get
            {
                return _CUIT;
            }
            set
            {
                _CUIT = value;
            }
        }
        public string CelularTelefono
        {
            get
            {
                return _celularTelefono;
            }
            set
            {
                _celularTelefono = value;
            }
        }
        public DateTime FechaPresupuesto
        {
            get
            {
                return _fechaPresupuesto;
            }
            set
            {
                _fechaPresupuesto = value;
            }
        }
        public string Modelo
        {
            get
            {
                return _modelo;
            }
            set
            {
                if ((value == null)
                    || (value == ""))
                    _modelo = "";
                else
                    // le asigno el primer caracter como mayúscula
                    _modelo = value.Substring(0, 1).ToUpper() + value.Substring(1);
            }
        }
        public string Marca
        {
            get
            {
                if (_marca == "")
                    return _marca;
                else
                    return Utilidades.ConvertFirstLetterToUpper(_marca);
            }
            set
            {
                if(_marca == "")
                    _marca = value;
                else
                    _marca = Utilidades.ConvertFirstLetterToUpper(value);
            }
        }
        public string Patente
        {
            get
            {
                return _patente.ToUpper();
            }
            set
            {
                _patente = value.ToUpper();
            }
        }
        //public string Aseguradora
        //{
        //    get
        //    {
        //        return Utilidades.ConvertFirstLetterToUpper(_aseguradora);
        //    }
        //    set
        //    {
        //        _aseguradora = Utilidades.ConvertFirstLetterToUpper(value);
        //    }
        //}
        public string Inspector
        {
            get
            {
                if (_inspector == "")
                    return _inspector;
                else 
                    return Utilidades.ConvertFirstLetterToUpper(_inspector);
            }
            set
            {
                if (value == "")
                    _inspector = "";
                else
                    _inspector = Utilidades.ConvertFirstLetterToUpper(value);
            }
        }
        public string ProveedorDeRepuestos
        {
            get
            {
                return Utilidades.ConvertFirstLetterToUpper(_proveedorDeRepuestos);
            }
            set
            {
                _proveedorDeRepuestos = Utilidades.ConvertFirstLetterToUpper(value);
            }
        }
        public string TipologiaDeAutoNombre
        {
            get
            {
                return _tipologiaDeAutoNombre;
            }
            set
            {
                _tipologiaDeAutoNombre = value;
            }
        }
        public decimal TipologiaDeAutoCoeficiente
        {
            get
            {
                return _tipologiaDeAutoCoeficiente;
            }
            set
            {
                _tipologiaDeAutoCoeficiente = value;
            }
        }
        public decimal CostoDePano
        {
            get
            {
                return _costoDePano;
            }
            set
            {
                _costoDePano = value;
            }
        }
        public DateTime FechaHoraUltimaActualizacion
        {
            get
            {
                return _fechaHoraUltimaActualizacion;
            }
            set
            {
                _fechaHoraUltimaActualizacion = value;
            }
        }
        public DateTime FechaHoraCreacion
        {
            get
            {
                return _fechaHoraCreacion;
            }
            set
            {
                _fechaHoraCreacion = value;
            }
        }
        public string Observaciones
        {
            get
            {
                return _Observaciones;
            }
            set
            {
                _Observaciones = value;
            }
        }
        public decimal AireAcondicionadoAutorizado
        {
            get
            {
                return _aireAcondicionadoAutorizado;
            }
            set
            {
                _aireAcondicionadoAutorizado = value;
            }
        }
        public decimal AireAcondicionadoOriginal
        {
            get
            {
                return _aireAcondicionadoOriginal;
            }
            set
            {
                _aireAcondicionadoOriginal = value;
            }
        }
        public decimal CerrajeriaAutorizado
        {
            get
            {
                return _cerrajeriaAutorizado;
            }
            set
            {
                _cerrajeriaAutorizado = value;
            }
        }
        public decimal CerrajeriaOriginal
        {
            get
            {
                return _cerrajeriaOriginal;
            }
            set
            {
                _cerrajeriaOriginal = value;
            }
        }
        public decimal ChaperiaAutorizado
        {
            get
            {
                return _chaperiaAutorizado;
            }
            set
            {
                _chaperiaAutorizado = value;
            }
        }
        public decimal ChaperiaOriginal
        {
            get
            {
                return _chaperiaOriginal;
            }
            set
            {
                _chaperiaOriginal = value;
            }
        }
        public decimal DespegadoYPegadoDeCristalesOriginal
        {
            get
            {
                return _despegadoYPegadoDeCristalesOriginal;
            }
            set
            {
                _despegadoYPegadoDeCristalesOriginal = value;
            }
        }
        public decimal DespegadoYPegadoDeCristalesAutorizado
        {
            get
            {
                return _despegadoYPegadoDeCristalesAutorizado;
            }
            set
            {
                _despegadoYPegadoDeCristalesAutorizado = value;
            }
        }
        public decimal ElectricidadOriginal
        {
            get
            {
                return _electricidadOriginal;
            }
            set
            {
                _electricidadOriginal = value;
            }
        }
        public decimal ElectricidadAutorizado
        {
            get
            {
                return _electricidadAutorizado;
            }
            set
            {
                _electricidadAutorizado = value;
            }
        }
        public decimal EnceradoAutorizado
        {
            get
            {
                return _enceradoAutorizado;
            }
            set
            {
                _enceradoAutorizado = value;
            }
        }
        public decimal EnceradoOriginal
        {
            get
            {
                return _enceradoOriginal;
            }
            set
            {
                _enceradoOriginal = value;
            }
        }
        public decimal MecanicaAutorizado
        {
            get
            {
                return _mecanicaAutorizado;
            }
            set
            {
                _mecanicaAutorizado = value;
            }
        }
        public decimal MecanicaOriginal
        {
            get
            {
                return _mecanicaOriginal;
            }
            set
            {
                _mecanicaOriginal = value;
            }
        }
        public decimal MecanicaTrenDelanteroAutorizado
        {
            get
            {
                return _mecanicaTrenDelanteroAutorizado;
            }
            set
            {
                _mecanicaTrenDelanteroAutorizado = value;
            }
        }
        public decimal MecanicaTrenDelanteroOriginal
        {
            get
            {
                return _mecanicaTrenDelanteroOriginal;
            }
            set
            {
                _mecanicaTrenDelanteroOriginal = value;
            }
        }
        public decimal PinturaOriginal
        {
            get
            {
                return _pinturaOriginal;
            }
            set
            {
                _pinturaOriginal = value;
            }
        }
        public decimal PinturaAutorizado
        {
            get
            {
                return _pinturaAutorizado;
            }
            set
            {
                _pinturaAutorizado = value;
            }
        }
        public decimal ReparacionPlasticosOriginal
        {
            get
            {
                return _reparacionPlasticosOriginal;
            }
            set
            {
                _reparacionPlasticosOriginal = value;
            }
        }
        public decimal ReparacionPlasticosAutorizado
        {
            get
            {
                return _reparacionPlasticosAutorizado;
            }
            set
            {
                _reparacionPlasticosAutorizado = value;
            }
        }
        public decimal RepuestosOriginal
        {
            get
            {
                return _repuestosOriginal;
            }
            set
            {
                _repuestosOriginal = value;
            }
        }
        public decimal RepuestosAutorizado
        {
            get
            {
                return _repuestosAutorizado;
            }
            set
            {
                _repuestosAutorizado = value;
            }
        }
        public decimal TapiceriaOriginal
        {
            get
            {
                return _tapiceriaOriginal;
            }
            set
            {
                _tapiceriaOriginal = value;
            }
        }
        public decimal TapiceriaAutorizado
        {
            get
            {
                return _tapiceriaAutorizado;
            }
            set
            {
                _tapiceriaAutorizado = value;
            }
        }
        public decimal LustreOriginal
        {
            get
            {
                return _lustreOriginal;
            }
            set
            {
                _lustreOriginal = value;
            }
        }
        public decimal LustreAutorizado
        {
            get
            {
                return _lustreAutorizado;
            }
            set
            {
                _lustreAutorizado = value;
            }
        }
        public decimal ArmadoOriginal
        {
            get
            {
                return _armadoOriginal;
            }
            set
            {
                _armadoOriginal = value;
            }
        }
        public decimal ArmadoAutorizado
        {
            get
            {
                return _armadoAutorizado;
            }
            set
            {
                _armadoAutorizado = value;
            }
        }
        public decimal DesarmadoOriginal
        {
            get
            {
                return _desarmadoOriginal;
            }
            set
            {
                _desarmadoOriginal = value;
            }
        }
        public decimal DesarmadoAutorizado
        {
            get
            {
                return _desarmadoAutorizado;
            }
            set
            {
                _desarmadoAutorizado = value;
            }
        }
        public decimal ElectronicaOriginal
        {
            get
            {
                return _electronicaOriginal;
            }
            set
            {
                _electronicaOriginal = value;
            }
        }
        public decimal ElectronicaAutorizado
        {
            get
            {
                return _electronicaAutorizado;
            }
            set
            {
                _electronicaAutorizado = value;
            }
        }
        public string NumeroDeChasis
        {
            get
            {
                if (_numeroDeChasis == null)
                    return "";
                return _numeroDeChasis.ToUpper();
            }
            set
            {
                _numeroDeChasis = value.ToUpper();
            }
        }
        public decimal TotalAutorizado
        {
            get
            {
                return _totalAutorizado;
            }
            set
            {
                _totalAutorizado = value;
            }
        }
        public decimal TotalOriginal
        {
            get
            {
                return _totalOriginal;
            }
            set
            {
                _totalOriginal = value;
            }
        }
        public decimal IVA
        {
            get
            {
                return _IVA;
            }
            set
            {
                _IVA = value;
            }
        }
        public decimal ReparacionPlasticosPorcentaje
        {
            get
            {
                return _ReparacionPlasticosPorcentaje;
            }
            set
            {
                _ReparacionPlasticosPorcentaje = value;
            }
        }
        public decimal DespegadoYPegadoDeCristalesPorcentaje
        {
            get
            {
                return _DespegadoYPegadoDeCristalesPorcentaje;
            }
            set
            {
                _DespegadoYPegadoDeCristalesPorcentaje = value;
            }
        }
        public decimal MecanicaPorcentaje
        {
            get
            {
                return _MecanicaPorcentaje;
            }
            set
            {
                _MecanicaPorcentaje = value;
            }
        }
        public decimal MecanicaTrenDelanteroPorcentaje
        {
            get
            {
                return _MecanicaTrenDelanteroPorcentaje;
            }
            set
            {
                _MecanicaTrenDelanteroPorcentaje = value;
            }
        }
        public decimal AireAcondicionadoPorcentaje
        {
            get
            {
                return _AireAcondicionadoPorcentaje;
            }
            set
            {
                _AireAcondicionadoPorcentaje = value;
            }
        }
        public decimal TapiceriaPorcentaje
        {
            get
            {
                return _TapiceriaPorcentaje;
            }
            set
            {
                _TapiceriaPorcentaje = value;
            }
        }
        public decimal CerrajeriaPorcentaje
        {
            get
            {
                return _CerrajeriaPorcentaje;
            }
            set
            {
                _CerrajeriaPorcentaje = value;
            }
        }
        public decimal ElectricidadPorcentaje
        {
            get
            {
                return _ElectricidadPorcentaje;
            }
            set
            {
                _ElectricidadPorcentaje = value;
            }
        }
        public decimal RepuestosPorcentaje
        {
            get
            {
                return _RepuestosPorcentaje;
            }
            set
            {
                _RepuestosPorcentaje = value;
            }
        }
        public decimal ElectronicaPorcentaje
        {
            get
            {
                return _ElectronicaPorcentaje;
            }
            set
            {
                _ElectronicaPorcentaje = value;
            }
        }
        public decimal IVAPresupuesto
        {
            get
            {
                return _IVAPresupuesto;
            }
            set
            {
                _IVAPresupuesto = value;
            }
        }
        public DateTime FechaFacturacion
        {
            get
            {
                return _FechaFacturacion;
            }
            set
            {
                _FechaFacturacion = value;
            }
        }
        public DateTime? FechaEntregaEstimada
        {
            get
            {
                return _FechaEntregaEstimada;
            }
            set
            {
                                    
                _FechaEntregaEstimada = value;
            }
        }
        public DateTime? FechaEntregaReal
        {
            get
            {
                return _FechaEntregaReal;
            }
            set
            {
                _FechaEntregaReal = value;
            }
        }
        public string NumeroDeSiniestro
        {
            get
            {
                return _NumeroDeSiniestro;
            }
            set
            {
                _NumeroDeSiniestro = value;
            }
        }
        public int EmpleadoChaperiaId
        {
            get
            {
                return _EmpleadoChaperiaId;
            }
            set
            {
                _EmpleadoChaperiaId = value;
            }
        }
        public int EmpleadoPinturaId
        {
            get
            {
                return _EmpleadoPinturaId;
            }
            set
            {
                _EmpleadoPinturaId = value;
            }
        }
        public bool RepuestosACargoDeLaCompaniaDeSeguros
        {
            get
            {
                return _RepuestosACargoDeLaCompaniaDeSeguros;
            }
            set
            {
                _RepuestosACargoDeLaCompaniaDeSeguros = value;
            }

        }
        public decimal DespegadoYPegadoDeMoldurasEInsigniasOriginal
        {
            get
            {
                return _DespegadoYPegadoDeMoldurasEInsigniasOriginal;
            }
            set
            {
                _DespegadoYPegadoDeMoldurasEInsigniasOriginal = value;
            }
        }
        public decimal DespegadoYPegadoDeMoldurasEInsigniasAutorizado
        {
            get
            {
                return _DespegadoYPegadoDeMoldurasEInsigniasAutorizado;
            }
            set
            {
                _DespegadoYPegadoDeMoldurasEInsigniasAutorizado = value;
            }
        }
        public decimal OtrosOriginal
        {
            get
            {
                return _OtrosOriginal;
            }
            set
            {
                _OtrosOriginal = value;
            }
        }
        public decimal OtrosAutorizado
        {
            get
            {
                return _OtrosAutorizado;
            }
            set
            {
                _OtrosAutorizado = value;
            }
        }
        public DateTime? FechaIngreso
        {
            get
            {
                return _FechaIngreso;
            }
            set
            {
                _FechaIngreso = value;
            }
        }
        public string CreadoPor
        {
            get
            {
                return _CreadoPor;
            }
            set
            {
                _CreadoPor = value;
            }
        }
        public string UltimaModificacionPor
        {
            get
            {
                return _UltimaModificacionPor;
            }
            set
            {
                _UltimaModificacionPor = value;
            }
        }
        public string AnoVehiculo
        {
            get
            {
                return _AnoVehiculo;
            }
            set
            {
                _AnoVehiculo = value;
            }
        }
        public string FacturaRepuestos
        {
            get
            {
                return _FacturaRepuestos;
            }
            set
            {
                _FacturaRepuestos = value;
            }
        }
        public string FacturaDeVenta
        {
            get
            {
                return _FacturaDeVenta;
            }
            set
            {
                _FacturaDeVenta = value;
            }
        }
        public string TipoFacturacion
        {
            get
            {
                return _TipoFacturacion;
            }
            set
            {
                _TipoFacturacion = value;
            }
        }
        public decimal FranquiciaOriginal
        {
            get
            {
                return _FranquiciaOriginal;
            }
            set
            {
                _FranquiciaOriginal = value;
            }
        }
        public decimal FranquiciaAutorizado
        {
            get
            {
                return _FranquiciaAutorizado;
            }
            set
            {
                _FranquiciaAutorizado = value;
            }
        }
        
        public int PresupuestoOriginalId
        {
            get
            {
                return _PresupuestoOriginalId;
            }
            set
            {
                _PresupuestoOriginalId = value;
            }
        }
        public string NumeroDeFactura
        {
            get
            {
                return _NumeroDeFactura;
            }
            set
            {
                _NumeroDeFactura = value;
            }
        }
        public string NumeroReciboTransferencia
        {
            get
            {
                return _NumeroReciboTransferencia;
            }
            set
            {
                _NumeroReciboTransferencia = value;
            }
        }
        public int AseguradoraId
        {
            get
            {
                return _AseguradoraId;
            }
            set
            {
                if ((_Aseguradora != null) && (_Aseguradora.ID != value)) // compruebo si el id es del mismo objeto para no tener que borrarlo
                    _Aseguradora = null;
                _AseguradoraId = value;
            }
        }

        public int UsuarioResponsableId
        {
            get
            {
                return _UsuarioResponsableId;
            }
            set
            {
                if ((UsuarioResponsable != null) && (UsuarioResponsable.ID != value)) // compruebo si el id es del mismo objeto para no tener que borrarlo
                    UsuarioResponsable = null;
                _UsuarioResponsableId = value;
            }
        }
        #region Propiedades asociadas al estado
        public string Estado
        {
            get
            {
                return _estado;
            }
            set
            {
                _estado = value;
            }
        }

        public void CambiarEstadoDePresupuestoAEnReparacion()
        {
        }

        //Indicadores booleanos para saber si se puede pasar de un estado a otro
        public enum enuEstados
        {
            Borrador,
            Cerrado,
            Presupuesto,
            Reparación,
            Facturado,
            Cancelado,
            Cobrado,
            Anotado
        }
        public bool EstadoPuedeFinalizarBorrador
        {
            get
            {
                if (Estado == enuEstados.Borrador.ToString())
                    return true;
                return false;
            }
        }
        public bool EstadoPuedeCerrar
        {
            get
            {
                if ((Estado == enuEstados.Borrador.ToString())
                    || (Estado == enuEstados.Presupuesto.ToString()))
                    return true;
                return false;
            }
        }
        public bool EstadoPuedePasarAReparacion
        {
            get
            {
                if ((Estado == enuEstados.Presupuesto.ToString())
                    || (Estado == enuEstados.Cerrado.ToString()))
                    return true;
                return false;
            }
        }
        public bool EstadoPuedePasarAFacturado
        {
            get
            {
                if ((Estado == enuEstados.Reparación.ToString())
                    || (Estado == enuEstados.Cancelado.ToString())
                    || (Estado == enuEstados.Anotado.ToString()))
                    return true;
                return false;
            }
        }
        public bool EstadoPuedePasarACancelado
        {
            get
            {
                if (Estado == enuEstados.Reparación.ToString())
                    return true;
                return false;
            }
        }
        public bool EstadoPuedePasarAAnotado
        {
            get
            {
                if (Estado == enuEstados.Reparación.ToString())
                    return true;
                return false;
            }
        }
        public bool EstadoPuedePasarACobrado
        {
            get
            {
                if (Estado == enuEstados.Facturado.ToString())
                    return true;
                return false;
            }
        }
        #endregion

        #region Propiedades Objetos
        public ONPresupuestoAlarmaColeccion Alarmas
        {
            get
            {
                if (_alarmas == null)
                    _alarmas = ONPresupuestoAlarmaColeccion.ObtenerAlarmasDePresupuesto(this.ID);

                return _alarmas;
            }
            set
            {
                _alarmas = value;
            }
        }
        public ONElementoColeccion TodosLosElementos
        {
            get 
            {
                if ((_TodosLosElementos == null)
                    || (_TodosLosElementos.Count == 0))
                {
                    _TodosLosElementos = new ONElementoColeccion();
                    _TodosLosElementos = _TodosLosElementos.ObtenerElementosPorPresupuesto(this.ID);
                }

                return _TodosLosElementos;
            }
        }
        public ONElementoColeccion ElementosAControlar
        {
            get
            {
                ONElementoColeccion _resultado = new ONElementoColeccion();
                foreach (ONElemento _elemento in this.TodosLosElementos)
                {
                    if (_elemento.Controlar == true)
                        _resultado.Add(_elemento);
                }
                return _resultado;
            }
        }
        public ONElementoColeccion ElementosAPintar
        {
            get
            {
                ONElementoColeccion _resultado = new ONElementoColeccion();
                foreach (ONElemento _elemento in this.TodosLosElementos)
                {
                    if (_elemento.Pintar == true)
                        _resultado.Add(_elemento);
                }
                return _resultado;
            }
        }
        

        public SGT_ON.Aseguradora Aseguradora
        {
            get
            {
                //if (AseguradoraId < 0)
                //{
                //    SGT_ON.Aseguradora _Aseguradora = new SGT_ON.Aseguradora();
                //    return _Aseguradora;
                //}

                if ((this._Aseguradora != null)
                    && (this._Aseguradora.ID == AseguradoraId))
                    return this._Aseguradora;

                this._Aseguradora = SGT_ON.Aseguradora.CrearAseguradora(AseguradoraId);
                return this._Aseguradora;
            }
            set
            {
                _Aseguradora = value;
                if (value == null)
                    _AseguradoraId = -1;
                else
                    _AseguradoraId = value.ID;
            }
        }
        public SGT_ON.ONEmpleado UsuarioResponsable
        {
            get
            {
                if (UsuarioResponsableId <= 0)
                {
                    SGT_ON.ONEmpleado _UsuarioResponsable = new SGT_ON.ONEmpleado();
                    return _UsuarioResponsable;
                }

                if ((this._UsuarioResponsable != null)
                    && (this._UsuarioResponsable.ID == UsuarioResponsableId))
                    return this._UsuarioResponsable;

                this._UsuarioResponsable = SGT_ON.ONEmpleado.CrearEmpleado(UsuarioResponsableId);
                return this._UsuarioResponsable;
            }
            set
            {
                _UsuarioResponsable = value;
                if (value == null)
                    _UsuarioResponsableId = -1;
                else
                    _UsuarioResponsableId = value.ID;
            }
        }
        #endregion
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static PresupuestoTableAdapter _presupuestoAD;
        protected static PresupuestoTableAdapter Adaptador
        {
            get
            {
                if (_presupuestoAD == null)
                    _presupuestoAD = new PresupuestoTableAdapter();

                return _presupuestoAD;
            }
        }
        protected static ONPresupuesto ObtenerPorID(int pID)
        {
            ONPresupuesto _presupuesto = new ONPresupuesto() ;
            
            SGT_DAL._STG_DAL.PresupuestoDataTable _dt;

            // obtengo el elemento por ID
            PresupuestoTableAdapter _adaptador = new PresupuestoTableAdapter(); // lo creo aca por que este es un metodo estatico
            _dt = _adaptador.ObtenerPorID(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                _presupuesto = AsignarRowAObjeto((_STG_DAL.PresupuestoRow)_dt.Rows[0]);
            
            return _presupuesto;
        }
        protected static ONPresupuesto AsignarRowAObjeto(_STG_DAL.PresupuestoRow pRow)
        {
            ONPresupuesto _presupuesto = null;
            if (pRow != null)
            {
                _presupuesto = new ONPresupuesto();
                _presupuesto.ID = pRow.ID;
                try { _presupuesto.Nombre = pRow.Nombre; }
                catch { _presupuesto.Nombre = ""; }
                try { _presupuesto.Apellido = pRow.Apellido; }
                catch { _presupuesto.Apellido = ""; }
                try { _presupuesto.CUIT = pRow.CUIT; }
                catch { _presupuesto.CUIT = ""; }
                try { _presupuesto.CelularTelefono = pRow.CelularTelefono; }
                catch { _presupuesto.CelularTelefono = ""; }
                try { _presupuesto.FechaPresupuesto = pRow.FechaPresupuesto; }
                catch { _presupuesto.FechaPresupuesto = DateTime.MinValue; }
                try { _presupuesto.Modelo = pRow.Modelo; }
                catch { _presupuesto.Modelo = ""; }
                try { _presupuesto.Marca = pRow.Marca; }
                catch { _presupuesto.Marca = ""; }
                try { _presupuesto.Patente = pRow.Patente; }
                catch { _presupuesto.Patente = ""; }
                //try { _presupuesto.Aseguradora = pRow.Aseguradora; }
                //catch { _presupuesto.Aseguradora = ""; }
                _presupuesto.AseguradoraId = pRow.AseguradoraId;
                try { _presupuesto.Inspector = pRow.Inspector; }
                catch { _presupuesto.Inspector = ""; }
                try { _presupuesto.ProveedorDeRepuestos = pRow.ProveedorDeRepuestos; }
                catch { _presupuesto.ProveedorDeRepuestos = ""; }
                try { _presupuesto.TipologiaDeAutoNombre = pRow.TipologiaDeAutoNombre; }
                catch { _presupuesto.TipologiaDeAutoNombre = ""; }
                try { _presupuesto.TipologiaDeAutoCoeficiente = pRow.TipologiaDeAutoCoeficiente; }
                catch { _presupuesto.TipologiaDeAutoCoeficiente = decimal.Zero; }
                try { _presupuesto.CostoDePano = pRow.CostoDePano; }
                catch { _presupuesto.CostoDePano = decimal.Zero; }
                try { _presupuesto.Estado = pRow.Estado; }
                catch { _presupuesto.Estado = ""; }
                try { _presupuesto.FechaHoraUltimaActualizacion = pRow.FechaHoraUltimaActualizacion; }
                catch { _presupuesto.FechaHoraUltimaActualizacion = DateTime.MinValue; }
                try { _presupuesto.FechaHoraCreacion = pRow.FechaHoraDeCreacion; }
                catch { _presupuesto.FechaHoraCreacion = DateTime.MinValue; }
                try { _presupuesto.Observaciones = pRow.Observaciones; }
                catch { _presupuesto.Observaciones = ""; }
                try { _presupuesto.AireAcondicionadoAutorizado = pRow.AireAcondicionadoAutorizado; }
                catch { _presupuesto.AireAcondicionadoAutorizado = decimal.Zero; }
                try { _presupuesto.AireAcondicionadoOriginal = pRow.AireAcondicionadoOriginal; }
                catch { _presupuesto.AireAcondicionadoOriginal = decimal.Zero; }
                try { _presupuesto.CerrajeriaAutorizado = pRow.CerrajeriaAutorizado; }
                catch { _presupuesto.CerrajeriaAutorizado = decimal.Zero; }
                try { _presupuesto.CerrajeriaOriginal = pRow.CerrajeriaOriginal; }
                catch { _presupuesto.CerrajeriaOriginal = decimal.Zero; }
                try { _presupuesto.ChaperiaAutorizado = pRow.ChaperiaAutorizado; }
                catch { _presupuesto.ChaperiaAutorizado = decimal.Zero; }
                try { _presupuesto.ChaperiaOriginal = pRow.ChaperiaOriginal; }
                catch { _presupuesto.ChaperiaOriginal = decimal.Zero; }
                try { _presupuesto.DespegadoYPegadoDeCristalesOriginal = pRow.DespegadoYPegadoDeCristalesOriginal; }
                catch { _presupuesto.DespegadoYPegadoDeCristalesOriginal = decimal.Zero; }
                try { _presupuesto.DespegadoYPegadoDeCristalesAutorizado = pRow.DespegadoYPegadoDeCristalesAutorizado; }
                catch { _presupuesto.DespegadoYPegadoDeCristalesAutorizado = decimal.Zero; }
                try { _presupuesto.ElectricidadOriginal = pRow.ElectricidadOriginal; }
                catch { _presupuesto.ElectricidadOriginal = decimal.Zero; }
                try { _presupuesto.ElectricidadAutorizado = pRow.ElectricidadAutorizado; }
                catch { _presupuesto.ElectricidadAutorizado = decimal.Zero; }
                try { _presupuesto.EnceradoAutorizado = pRow.EnceradoAutorizado; }
                catch { _presupuesto.EnceradoAutorizado = decimal.Zero; }
                try { _presupuesto.EnceradoOriginal = pRow.EnceradoOriginal; }
                catch { _presupuesto.EnceradoOriginal = decimal.Zero; }
                try { _presupuesto.MecanicaAutorizado = pRow.MecanicaAutorizado; }
                catch { _presupuesto.MecanicaAutorizado = decimal.Zero; }
                try { _presupuesto.MecanicaOriginal = pRow.MecanicaOriginal; }
                catch { _presupuesto.MecanicaOriginal = decimal.Zero; }
                try { _presupuesto.MecanicaTrenDelanteroAutorizado = pRow.MecanicaTrenDelanteroAutorizado; }
                catch { _presupuesto.MecanicaTrenDelanteroAutorizado = decimal.Zero; }
                try { _presupuesto.MecanicaTrenDelanteroOriginal = pRow.MecanicaTrenDelanteroOriginal; }
                catch { _presupuesto.MecanicaTrenDelanteroOriginal = decimal.Zero; }
                try { _presupuesto.PinturaOriginal = pRow.PinturaOriginal; }
                catch { _presupuesto.PinturaOriginal = decimal.Zero; }
                try { _presupuesto.PinturaAutorizado = pRow.PinturaAutorizado; }
                catch { _presupuesto.PinturaAutorizado = decimal.Zero; }
                try { _presupuesto.ReparacionPlasticosOriginal = pRow.ReparacionPlasticosOriginal; }
                catch { _presupuesto.ReparacionPlasticosOriginal = decimal.Zero; }
                try { _presupuesto.ReparacionPlasticosAutorizado = pRow.ReparacionPlasticosAutorizado; }
                catch { _presupuesto.ReparacionPlasticosAutorizado = decimal.Zero; }
                try { _presupuesto.RepuestosOriginal = pRow.RepuestosOriginal; }
                catch { _presupuesto.RepuestosOriginal = decimal.Zero; }
                try { _presupuesto.RepuestosAutorizado = pRow.RepuestosAutorizado; }
                catch { _presupuesto.RepuestosAutorizado = decimal.Zero; }
                try { _presupuesto.TapiceriaOriginal = pRow.TapiceriaOriginal; }
                catch { _presupuesto.TapiceriaOriginal = decimal.Zero; }
                try { _presupuesto.TapiceriaAutorizado = pRow.TapiceriaAutorizado; }
                catch { _presupuesto.TapiceriaAutorizado = decimal.Zero; }
                try { _presupuesto.LustreOriginal = pRow.LustreOriginal; }
                catch { _presupuesto.LustreOriginal = decimal.Zero; }
                try { _presupuesto.LustreAutorizado = pRow.LustreAutorizado; }
                catch { _presupuesto.LustreAutorizado = decimal.Zero; }
                try { _presupuesto.ArmadoOriginal = pRow.ArmadoOriginal; }
                catch { _presupuesto.ArmadoOriginal = decimal.Zero; }
                try { _presupuesto.ArmadoAutorizado = pRow.ArmadoAutorizado; }
                catch { _presupuesto.ArmadoAutorizado = decimal.Zero; }
                try { _presupuesto.DesarmadoOriginal = pRow.DesarmadoOriginal; }
                catch { _presupuesto.DesarmadoOriginal = decimal.Zero; }
                try { _presupuesto.DesarmadoAutorizado = pRow.DesarmadoAutorizado; }
                catch { _presupuesto.DesarmadoAutorizado = decimal.Zero; }
                try { _presupuesto.ElectronicaOriginal = pRow.ElectronicaOriginal; }
                catch { _presupuesto.ElectronicaOriginal = decimal.Zero; }
                try { _presupuesto.ElectronicaAutorizado = pRow.ElectronicaAutorizado; }
                catch { _presupuesto.ElectronicaAutorizado = decimal.Zero; }
                try { _presupuesto.NumeroDeChasis = pRow.NumeroDeChasis; }
                catch { _presupuesto.NumeroDeChasis = ""; }
                try { _presupuesto.TotalAutorizado = pRow.TotalAutorizado; }
                catch { _presupuesto.TotalAutorizado = decimal.Zero; }
                try { _presupuesto.TotalOriginal = pRow.TotalOriginal; }
                catch { _presupuesto.TotalOriginal = decimal.Zero; }
                try { _presupuesto.IVA = pRow.IVA; }
                catch { _presupuesto.IVA = decimal.Zero; }                
                try { _presupuesto.ReparacionPlasticosPorcentaje = pRow.ReperacionPlasticosPorcentaje; }
                catch { }
                try { _presupuesto.DespegadoYPegadoDeCristalesPorcentaje = pRow.DespegadoPegadoCristalesPorcentaje; }
                catch { }
                try { _presupuesto.MecanicaPorcentaje = pRow.MecanicaPorcentaje; }
                catch { }
                try { _presupuesto.MecanicaTrenDelanteroPorcentaje = pRow.MecanicaTrenDelanteroPorcentaje; }
                catch { }
                try { _presupuesto.AireAcondicionadoPorcentaje = pRow.AireAcondicionadoPorcentaje; }
                catch { }
                try { _presupuesto.TapiceriaPorcentaje = pRow.TapiceriaPorcentaje; }
                catch { }
                try { _presupuesto.CerrajeriaPorcentaje = pRow.CerrajeriaPorcentaje; }
                catch { }
                try { _presupuesto.ElectricidadPorcentaje = pRow.ElectricidadPorcentaje; }
                catch { }
                try { _presupuesto.RepuestosPorcentaje = pRow.RepuestosPorcentaje; }
                catch { }
                try { _presupuesto.ElectronicaPorcentaje = pRow.ElectronicaPorcentaje; }
                catch { }
                try { _presupuesto.IVAPresupuesto = pRow.IVAPresupuesto; }
                catch { }
                try { _presupuesto.FechaFacturacion = pRow.FechaFacturacion; }
                catch { _presupuesto.FechaFacturacion = DateTime.MinValue; }
                if (!pRow.IsFechaEntregaEstimadaNull())
                    _presupuesto.FechaEntregaEstimada = pRow.FechaEntregaEstimada;
                else
                    _presupuesto.FechaEntregaEstimada = null;

                if (!pRow.IsFechaEntregaRealNull())
                    _presupuesto.FechaEntregaReal = pRow.FechaEntregaReal;
                else
                    _presupuesto.FechaEntregaReal = null;
                
                _presupuesto.NumeroDeSiniestro = pRow.NumeroDeSiniestro;
                _presupuesto.EmpleadoChaperiaId = pRow.EmpleadoChaperiaId;
                _presupuesto.EmpleadoPinturaId = pRow.EmpleadoPinturaId;

                _presupuesto.RepuestosACargoDeLaCompaniaDeSeguros = pRow.RepuestosACargoDeLaCompaniaDeSeguros;

                if(!pRow.IsDespegadoYPegadoDeMoldurasEInsigniasAutorizadoNull())
                    _presupuesto.DespegadoYPegadoDeMoldurasEInsigniasAutorizado = pRow.DespegadoYPegadoDeMoldurasEInsigniasAutorizado;
                else
                    _presupuesto.DespegadoYPegadoDeMoldurasEInsigniasAutorizado = decimal.Zero;

                if (!pRow.IsDespegadoYPegadoDeMoldurasEInsigniasOriginalNull())
                    _presupuesto.DespegadoYPegadoDeMoldurasEInsigniasOriginal = pRow.DespegadoYPegadoDeMoldurasEInsigniasOriginal;
                else
                    _presupuesto.DespegadoYPegadoDeMoldurasEInsigniasOriginal = decimal.Zero;

                if (!pRow.IsOtrosOriginalNull())
                    _presupuesto.OtrosOriginal = pRow.OtrosOriginal;
                else
                    _presupuesto.OtrosOriginal = decimal.Zero;

                if (!pRow.IsOtrosAutorizadoNull())
                    _presupuesto.OtrosAutorizado = pRow.OtrosAutorizado;
                else
                    _presupuesto.OtrosAutorizado = decimal.Zero;

                if (!pRow.IsFechaIngresoNull())
                    _presupuesto.FechaIngreso = pRow.FechaIngreso;
                else
                    _presupuesto.FechaIngreso = null;

                if (pRow.IsCreadoPorNull())
                    _presupuesto.CreadoPor = "";
                else
                    _presupuesto.CreadoPor = pRow.CreadoPor;

                if (pRow.IsUltimaModificacionPorNull())
                    _presupuesto.UltimaModificacionPor = "";
                else
                    _presupuesto.UltimaModificacionPor = pRow.UltimaModificacionPor;

                if (pRow.IsAnoVehiculoNull())
                    _presupuesto.AnoVehiculo = "";
                else
                    _presupuesto.AnoVehiculo = pRow.AnoVehiculo;
                if (pRow.IsFacturaRepuestosNull())
                    _presupuesto.FacturaRepuestos = "";
                else
                    _presupuesto.FacturaRepuestos = pRow.FacturaRepuestos;
                if (pRow.IsFacturaDeVentaNull())
                    _presupuesto.FacturaDeVenta = "";
                else
                    _presupuesto.FacturaDeVenta = pRow.FacturaDeVenta;
                if (pRow.IsTipoFacturacionNull())
                    _presupuesto.TipoFacturacion = "";
                else
                    _presupuesto.TipoFacturacion = pRow.TipoFacturacion;
                if (!pRow.IsFranquiciaOriginalNull())
                    _presupuesto.FranquiciaOriginal = pRow.FranquiciaOriginal;
                else
                    _presupuesto.FranquiciaOriginal = decimal.Zero;
                if (!pRow.IsFranquiciaAutorizadoNull())
                    _presupuesto.FranquiciaAutorizado = pRow.FranquiciaAutorizado;
                else
                    _presupuesto.FranquiciaAutorizado = decimal.Zero;
                _presupuesto.PresupuestoOriginalId = pRow.PresupuestoOriginalId;
                if (!pRow.IsNumeroDeFacturaNull())
                    _presupuesto.NumeroDeFactura = pRow.NumeroDeFactura;
                else
                    _presupuesto.NumeroDeFactura = "";
                if (!pRow.IsNumeroReciboTransferenciaNull())
                    _presupuesto.NumeroReciboTransferencia = pRow.NumeroReciboTransferencia;
                else
                    _presupuesto.NumeroReciboTransferencia = "";

                _presupuesto.UsuarioResponsableId = pRow.UsuarioResponsableId;
            }
            return _presupuesto;
        }

        protected ONPresupuesto InsertarDAL(string pNombre, string pApellido, string pCUIT, string pCelularTelefono, string pProveedorDeRepuestos, DateTime pFechaPresupuesto, string pModelo, string pMarca, string pPatente, string pInspector, string pPoveedorDeRepuestos, string pTipologiaDeAutoNombre, decimal pTipoligiaDeAutoCoeficiente, decimal pCostoDePano, string pEstado, DateTime pFechaHoraUltimaActualizacion, DateTime pFechaHoraCreacion, string pObservaciones, decimal pAireAcondicionadoAutorizado, decimal pAireAcondicionadoOriginal, decimal pCerrajeriaAutorizado, decimal pCerrajeriaOriginal, decimal pChaperiaAutorizado, decimal pChaperiaOriginal, decimal pDespegadoYPegadoDeCristalesOriginal, decimal pDespegadoYPegadoDeCristalesAutorizado, decimal pElectricidadOriginal, decimal pElectricidadAutorizado, decimal pEnceradoAutorizado, decimal pEnceradoOriginal, decimal pMecanicaAutorizado, decimal pMecanicaOriginal, decimal pMecanicaTrenDelanteroAutorizado, decimal pMecanicaTrenDelateroOriginal, decimal pPinturaOriginal, decimal pPinturaAutorizado, decimal pReparacionPlasticosOriginal, decimal pReparacionPlasticosAutorizado, decimal pRepuestosOriginal, decimal pRepuestosAutorizado, decimal pTapiceriaOriginal, decimal pTapiceriaAutorizado, decimal pLustreOriginal, decimal pLustreAutorizado, decimal pArmadoOriginal, decimal pArmadoAutorizado, decimal pDesarmadoOriginal, decimal pDesarmadoAutorizado, decimal pElectronicaOriginal, decimal pElectronicaAutorizado, string pNumeroDeChasis, decimal pTotalOriginal, decimal pTotalAutorizado, decimal pIVA, decimal pReparacionPlasticosPorcentaje, decimal pDespegadoYPegadoDeCristalesPorcentaje, decimal pMecanicaPorcentaje, decimal pMecanicaTrenDelanteroPorcentaje, decimal pAireAcondicionadoPorcentaje, decimal pTapiceriaPorcentaje, decimal pCerrajeriaPorcentaje, decimal pElectricidadPorcentaje, decimal pRepuestosPorcentaje, decimal pElectronicaPorcentaje, decimal pIVAPresupuesto, DateTime pFechaFacturacion, DateTime? pFechaEntregaEstimada, DateTime? pFechaEntregaReal, string pNumeroDeSiniestro, int pEmpleadoChaperiaId, int pEmpleadoPinturaId, bool pRepuestosACargoDeLaCompaniaDeSeguros, decimal pDespegadoYPegadoDeMoldurasEInsigniasOriginal, decimal pDespegadoYPegadoDeMoldurasEInsigniasAutorizado, decimal pOtrosOriginal, decimal pOtrosAutorizado, DateTime? pFechaIngreso, string pCreadoPor, string pUltimaModificacionPor, string pAnoVehiculo, string pFacturaRepuestos, string pFacturaDeVenta, string pTipoFacturacion, decimal pFranquiciaOriginal, decimal pFranquiciaAutorizado, int pPresupuestoOriginalId, string pNumeroDeFactura, string pNumeroReciboTransferencia, int pAseguradoraId, int pUsuarioResponsableId)
        {
            if ((pEstado == null)
                || (pEstado == ""))
                pEstado = enuEstados.Borrador.ToString();

            if (Estado != ONPresupuesto.enuEstados.Facturado.ToString())
                pUsuarioResponsableId = -1;

            ID = int.Parse(Adaptador.Insertar(pNombre, pApellido, pCUIT, pCelularTelefono, pFechaPresupuesto, pModelo, pMarca, pPatente, pInspector, pProveedorDeRepuestos, pTipologiaDeAutoNombre, pTipoligiaDeAutoCoeficiente, pCostoDePano, pEstado, pFechaHoraUltimaActualizacion, pFechaHoraCreacion, pObservaciones, pAireAcondicionadoAutorizado, pAireAcondicionadoOriginal, pCerrajeriaAutorizado, pCerrajeriaOriginal, pChaperiaAutorizado, pChaperiaOriginal, pDespegadoYPegadoDeCristalesOriginal, pDespegadoYPegadoDeCristalesAutorizado, pElectricidadOriginal, pElectricidadAutorizado, pEnceradoAutorizado, pEnceradoOriginal, pMecanicaAutorizado, pMecanicaOriginal, pMecanicaTrenDelanteroAutorizado, pMecanicaTrenDelateroOriginal, pPinturaOriginal, pPinturaAutorizado, pReparacionPlasticosOriginal, pReparacionPlasticosAutorizado, pRepuestosAutorizado, pRepuestosOriginal, pTapiceriaOriginal, pTapiceriaAutorizado, pLustreOriginal, pLustreAutorizado, pArmadoOriginal, pArmadoAutorizado, pDesarmadoOriginal, pDesarmadoAutorizado, pElectronicaOriginal, pElectronicaAutorizado, pNumeroDeChasis, pTotalOriginal, pTotalAutorizado, pIVA, pReparacionPlasticosPorcentaje, pDespegadoYPegadoDeCristalesPorcentaje, pMecanicaPorcentaje, pMecanicaTrenDelanteroPorcentaje, pAireAcondicionadoPorcentaje, pTapiceriaPorcentaje, pCerrajeriaPorcentaje, pElectricidadPorcentaje, pRepuestosPorcentaje, pElectronicaPorcentaje, pIVAPresupuesto, pFechaFacturacion, pFechaEntregaEstimada, pFechaEntregaReal, pNumeroDeSiniestro, pEmpleadoChaperiaId, pEmpleadoPinturaId, pRepuestosACargoDeLaCompaniaDeSeguros, pDespegadoYPegadoDeMoldurasEInsigniasOriginal, pDespegadoYPegadoDeMoldurasEInsigniasAutorizado, pOtrosOriginal, pOtrosAutorizado, pFechaIngreso, pCreadoPor, pUltimaModificacionPor, pAnoVehiculo, pFacturaRepuestos, pFacturaDeVenta, pTipoFacturacion, pFranquiciaOriginal, pFranquiciaAutorizado, pPresupuestoOriginalId, pNumeroDeFactura, pNumeroReciboTransferencia, pAseguradoraId, pUsuarioResponsableId).ToString());
            
            // si se puso en facturado, la fecha de la alarma se tiene que actualizar sola.
            //if (Estado == "Facturado")
            //        CrearNuevaAlarmaPorFacturacion();
            return this;
        }
        protected void CrearNuevaAlarmaPorFacturacion()
        {
            ONPresupuestoAlarma _presupuestoAlarma = new ONPresupuestoAlarma();
            _presupuestoAlarma.EstaActiva = true;
            _presupuestoAlarma.FechaHora = DateTime.Now.AddDays(CantidadDeDiasAlarmaFacturacionPorDefecto);
            _presupuestoAlarma.IdPresupuesto = ID;
            _presupuestoAlarma.Motivo = "(A) Alarma por facturación.";
            Alarmas.Add(_presupuestoAlarma.Insertar());
        }
        protected bool ActualizarDAL(string pNombre, string pApellido, string pCUIT, string pCelularTelefono, DateTime pFechaPresupuesto, string pModelo, string pMarca, string pPatente, string pInspector, string pPoveedorDeRepuestos, string pTipologiaDeAutoNombre, decimal pTipoligiaDeAutoCoeficiente, decimal pCostoDePano, string pEstado, string pObservaciones, decimal pAireAcondicionadoAutorizado, decimal pAireAcondicionadoOriginal, decimal pCerrajeriaAutorizado, decimal pCerrajeriaOriginal, decimal pChaperiaAutorizado, decimal pChaperiaOriginal, decimal pDespegadoYPegadoDeCristalesOriginal, decimal pDespegadoYPegadoDeCristalesAutorizado, decimal pElectricidadOriginal, decimal pElectricidadAutorizado, decimal pEnceradoAutorizado, decimal pEnceradoOriginal, decimal pMecanicaAutorizado, decimal pMecanicaOriginal, decimal pMecanicaTrenDelanteroAutorizado, decimal pMecanicaTrenDelateroOriginal, decimal pPinturaOriginal, decimal pPinturaAutorizado, decimal pReparacionPlasticosOriginal, decimal pReparacionPlasticosAutorizado, decimal pRepuestosOriginal, decimal pRepuestosAutorizado, decimal pTapiceriaOriginal, decimal pTapiceriaAutorizado, decimal pLustreOriginal, decimal pLustreAutorizado, decimal pArmadoOriginal, decimal pArmadoAutorizado, decimal pDesarmadoOriginal, decimal pDesarmadoAutorizado, decimal pElectronicaOriginal, decimal pElectronicaAutorizado, string pNumeroDeChasis, decimal pTotalOriginal, decimal pTotalAutorizado, decimal pIVA, decimal pReparacionPlasticosPorcentaje, decimal pDespegadoYPegadoDeCristalesPorcentaje, decimal pMecanicaPorcentaje, decimal pMecanicaTrenDelanteroPorcentaje, decimal pAireAcondicionadoPorcentaje, decimal pTapiceriaPorcentaje, decimal pCerrajeriaPorcentaje, decimal pElectricidadPorcentaje, decimal pRepuestosPorcentaje, decimal pElectronicaPorcentaje, decimal pIVAPresupuesto, DateTime pFechaFacturacion, DateTime? pFechaEntregaEstimada, DateTime? pFechaEntregaReal, string pNumeroDeSiniestro, int pEmpleadoChaperiaId, int pEmpleadoPinturaId, bool pRepuestosACargoDeLaCompaniaDeSeguros, decimal pDespegadoYPegadoDeMoldurasEInsigniasOriginal, decimal pDespegadoYPegadoDeMoldurasEInsigniasAutorizado, DateTime pFechaHoraCreacion, decimal pOtrosOriginal, decimal pOtrosAutorizado, DateTime? pFechaIngreso, string pUltimaModificacionPor, string pAnoVehiculo, string pFacturaRepuestos, string pFacturaDeVenta, string pTipoFacturacion, decimal pFranquiciaOriginal, decimal pFranquiciaAutorizado, int pPresupuestoOriginalId, string pNumeroDeFactura, string pNumeroReciboTransferencia, int pAseguradoraId, int pUsuarioResponsableId, int pID )
        {
            ONPresupuesto _presupuesto = null;
            _presupuesto = ONPresupuesto.ObtenerPorID(pID); //traigo el presupuesto original

            if ((pEstado == "Facturado") // si se ha cambiado por primera vez a facturado, tengo que ajustar la fecha de facturiación a hoy.
                    && (_presupuesto.Estado != pEstado))
                pFechaFacturacion = DateTime.Now;
            

            //si el presupuesto no estaba en estado Reparación y pasa al estado reparación, tengo que asignarle el responsable.
            if(_presupuesto.Estado != enuEstados.Reparación.ToString()
                && (pEstado == enuEstados.Reparación.ToString()))
            {   
                
            }
            else
            {
                // dejo el responsable que estaba.
                pUsuarioResponsableId = _presupuesto.UsuarioResponsableId;
            }


            ///CreadoPor NO TIENE QUE SER ACTUALIZADO.
            if (0 < Adaptador.Actualizar(pNombre, pApellido, pCUIT, pCelularTelefono, pFechaPresupuesto, pModelo, pMarca, pPatente, pInspector, pPoveedorDeRepuestos, pTipologiaDeAutoNombre, pTipoligiaDeAutoCoeficiente, pCostoDePano, pEstado, DateTime.Now, pObservaciones, pAireAcondicionadoAutorizado, pAireAcondicionadoOriginal, pCerrajeriaAutorizado, pCerrajeriaOriginal, pChaperiaAutorizado, pChaperiaOriginal, pDespegadoYPegadoDeCristalesOriginal, pDespegadoYPegadoDeCristalesAutorizado, pElectricidadOriginal, pElectricidadAutorizado, pEnceradoAutorizado, pEnceradoOriginal, pMecanicaAutorizado, pMecanicaOriginal, pMecanicaTrenDelanteroAutorizado, pMecanicaTrenDelateroOriginal, pPinturaOriginal, pPinturaAutorizado, pReparacionPlasticosOriginal, pReparacionPlasticosAutorizado, pRepuestosAutorizado, pRepuestosOriginal, pTapiceriaOriginal, pTapiceriaAutorizado, pLustreOriginal, pLustreAutorizado, pArmadoOriginal, pArmadoAutorizado, pDesarmadoOriginal, pDesarmadoAutorizado, pElectronicaOriginal, pElectronicaAutorizado, pNumeroDeChasis, pTotalOriginal, pTotalAutorizado, pIVA, pReparacionPlasticosPorcentaje, pDespegadoYPegadoDeCristalesPorcentaje, pMecanicaPorcentaje, pMecanicaTrenDelanteroPorcentaje, pAireAcondicionadoPorcentaje, pTapiceriaPorcentaje, pCerrajeriaPorcentaje, pElectricidadPorcentaje, pRepuestosPorcentaje, pElectronicaPorcentaje, pIVAPresupuesto, pFechaFacturacion, pFechaEntregaEstimada, pFechaEntregaReal, pNumeroDeSiniestro, pEmpleadoChaperiaId, pEmpleadoPinturaId, pFechaHoraCreacion, pRepuestosACargoDeLaCompaniaDeSeguros, pDespegadoYPegadoDeMoldurasEInsigniasOriginal, pDespegadoYPegadoDeMoldurasEInsigniasAutorizado, pOtrosOriginal, pOtrosAutorizado, pFechaIngreso, pUltimaModificacionPor, pAnoVehiculo, pFacturaRepuestos, pFacturaDeVenta, pTipoFacturacion, pFranquiciaOriginal, pFranquiciaAutorizado, pPresupuestoOriginalId, pNumeroDeFactura, pNumeroReciboTransferencia, pAseguradoraId, pUsuarioResponsableId, pID))
            {
                SilenciarAlertasSiEsNecesario();
                return true;
            }
            else
                return false;
        }        
        
        protected static ONPresupuestoColeccion AsignarPresupuestoTableAdapterAPresupuestoColeccion(_STG_DAL.PresupuestoDataTable pDataTable)
        {
            ONPresupuestoColeccion _presupuestos = new ONPresupuestoColeccion(); ;
            ONPresupuesto _presupuesto;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.PresupuestoRow _row in pDataTable.Rows)
                {
                    _presupuesto = AsignarRowAObjeto(_row);
                    if (_presupuesto != null)
                        _presupuestos.AgregarAColeccion(_presupuesto);
                }
            }
            return _presupuestos;
        }
        public  static ONPresupuestoColeccion ObtenerPor(string pDesde, string pHasta, string pTexto, string pEstado)
        {
            _STG_DAL.PresupuestoDataTable _dt;

            DateTime _desde, _hasta;
            if (DateTime.TryParse(pDesde, out _desde) == false)
                _desde = DateTime.Parse("01/01/1900");

            if (DateTime.TryParse(pHasta, out _hasta) == false)
                _hasta = DateTime.Parse("01/01/1900");

            _hasta = _hasta.AddDays(1).AddSeconds(-1);

            if (pTexto == null)
                pTexto = "";

            if ((pEstado == null) || (pEstado == "Todos"))
                pEstado = "%%"; //al enviarlo con esto, devuelve todos los elementos

            pTexto = "%" + pTexto + "%";//al enviarlo con esto, devuelve todos los elementos q contengan una parte de loq ue tiene pTexto

            PresupuestoTableAdapter _adaptador = new PresupuestoTableAdapter(); // lo creo aca por que este es un metodo estatico
            _dt = _adaptador.ObtenerPor(_desde, _hasta, pTexto, pEstado);

            ONPresupuestoColeccion _resultado = AsignarPresupuestoTableAdapterAPresupuestoColeccion(_dt);

            ///////////////////////////////////
            // verfico por la franquicia segun lo solicitaod
            _resultado = BuscarPorFranquiciaSiCorresponde(_desde, _hasta, pTexto, pEstado, _resultado);
            // fin verificacion por franquicia
            ////////////////////////////////////////////
            return _resultado;
        }
        private static ONPresupuestoColeccion BuscarPorFranquiciaSiCorresponde(DateTime pDesde,DateTime pHasta,string pTexto,string pEstado, ONPresupuestoColeccion pResultado)
        {
            if (pEstado.Contains("Cobrado") == true)
            {//Es cobrado entoncse tengo que buscar los presupuestos que estan facturados y que tienen franquicia con factura C y devolver el presupuesto con el valor de la franquicia
                //busco los presupuestos facturados
                string _estado = "Facturado";
                PresupuestoTableAdapter _adaptador = new PresupuestoTableAdapter(); // lo creo aca por que este es un metodo estatico
                _STG_DAL.PresupuestoDataTable _dt = _adaptador.ObtenerPor(pDesde, pHasta, pTexto, _estado);
                ONPresupuestoColeccion _presupuestosFacturados = AsignarPresupuestoTableAdapterAPresupuestoColeccion(_dt);
                ONPresupuesto _presupuestoNuevo;

                // verifico que tenga franquicia y que la misma haya sido facturada como C
                foreach (ONPresupuesto _presupuesto in _presupuestosFacturados)
                {
                    if (((_presupuesto.FranquiciaAutorizado > 0) || (_presupuesto.FranquiciaOriginal > 0))
                        && (_presupuesto.TipoFacturacion == "C"))
                    {
                        //asigno el valor de la franquicia al presupuesto y lo pongo en el resultado de los cobrados
                        _presupuestoNuevo = new ONPresupuesto();
                        _presupuestoNuevo.FechaFacturacion = _presupuesto.FechaFacturacion;
                        _presupuestoNuevo.FechaHoraCreacion = _presupuesto.FechaHoraCreacion;
                        _presupuestoNuevo.FechaPresupuesto = _presupuesto.FechaPresupuesto;
                        _presupuestoNuevo.Marca = _presupuesto.Marca;
                        _presupuestoNuevo.Patente = _presupuesto.Patente;
                        _presupuestoNuevo.Nombre = _presupuesto.Nombre;
                        _presupuestoNuevo.Apellido = _presupuesto.Apellido;
                        _presupuestoNuevo.Estado = _presupuesto.Estado;
                        _presupuestoNuevo.TipoFacturacion = _presupuesto.TipoFacturacion;

                        _presupuestoNuevo.FranquiciaAutorizado = _presupuesto.FranquiciaAutorizado;
                        _presupuestoNuevo.FranquiciaOriginal = _presupuesto.FranquiciaOriginal;
                        pResultado.AgregarAColeccion(_presupuestoNuevo);
                    }
                }
            }
            return pResultado;

        }
        /// <summary>
        /// Obtiene los presupuestos que tienen que ser entregados proximos a los parametros enviados
        /// </summary>
        /// <param name="pEstado"></param>
        /// <param name="pFechaMaxima">Es la fecha máxima desde la que se buscan presupuestos por FechaEntregaEstimada</param>
        /// <param name="pOrigen"></param>
        /// <returns></returns>
        public static ONPresupuestoColeccion ObtenerPresupuestosConEntregaProxima(string pEstado,DateTime pFechaMaxima,string pOrigen)
        {
            return AsignarPresupuestoTableAdapterAPresupuestoColeccion(Adaptador.ObtenerPresupuestosConEntregaProxima(pEstado, pFechaMaxima, pOrigen));
        }
        /// <summary>
        /// Obtiene los presupuestos cuya fecha de creación es mayor a la FechaDesde y el estado es el indicado
        /// </summary>
        /// <param name="pEstado"></param>
        /// <param name="pFechaDesde"></param>
        /// <returns></returns>
        public static ONPresupuestoColeccion ObtenerPresupuestosPorFechaDesdeYEstado(string pEstado,DateTime pFechaDesde)
        {
            return AsignarPresupuestoTableAdapterAPresupuestoColeccion(Adaptador.ObtenerPresupuestosPorFechaDesdeYEstado(pEstado, pFechaDesde));
        }
        
        /// <summary>
        /// Obtiene los presupuestos que tienen alerta de facturación activa.
        /// Alertas - Rol comercial: Se generará la alerta si el estado del presupuesto es Facturado y la
        /// fecha de facturación / anotado más la cantidad de días definidos en los parámetros del
        /// sistema en la sección de compañías, es mayor a la fecha actual
        /// </summary>
        /// <returns></returns>
        public static ONPresupuestoColeccion ObtenerPresupuestosConAlertaDeFacturacion(string pOrigen)
        {
            return AsignarPresupuestoTableAdapterAPresupuestoColeccion(Adaptador.ObtenerPresupuestosConAlertaDeFacturacion(pOrigen));
        }
        #endregion

        #region Métodos
        public ONPresupuesto()
        {
            AsignarValoresIniciales();
        }        

        public void AsignarValoresIniciales()
        {
            _id = -1;
            Nombre = "";
            Apellido = "";
            CelularTelefono = "";
            FechaPresupuesto = DateTime.Now;
            Modelo = "";
            Marca = "";
            Patente = "";
            //Aseguradora = "";
            Inspector = "";
            ProveedorDeRepuestos = "";
            TipologiaDeAutoNombre = "Bicuerpo 3 ptas";
            TipologiaDeAutoCoeficiente = decimal.Parse("1.0");
            CostoDePano = CostoDePanoParametro;
            Estado = "Borrador";
            FechaHoraUltimaActualizacion = DateTime.Now;
            FechaHoraCreacion = DateTime.Now;
            Observaciones = "";
            AireAcondicionadoAutorizado = decimal.Zero;
            AireAcondicionadoOriginal = decimal.Zero;
            CerrajeriaAutorizado = decimal.Zero;
            CerrajeriaOriginal = decimal.Zero;
            ChaperiaAutorizado = decimal.Zero;
            ChaperiaOriginal = decimal.Zero;
            DespegadoYPegadoDeCristalesAutorizado = decimal.Zero;
            DespegadoYPegadoDeCristalesOriginal = decimal.Zero;
            ElectricidadAutorizado = decimal.Zero;
            ElectricidadOriginal = decimal.Zero;
            EnceradoAutorizado = decimal.Zero;
            EnceradoOriginal = decimal.Zero;
            MecanicaAutorizado = decimal.Zero;
            MecanicaOriginal = decimal.Zero;
            MecanicaTrenDelanteroAutorizado = decimal.Zero;
            MecanicaTrenDelanteroOriginal = decimal.Zero;
            PinturaAutorizado = decimal.Zero;
            PinturaOriginal = decimal.Zero;
            ReparacionPlasticosAutorizado = decimal.Zero;
            ReparacionPlasticosOriginal = decimal.Zero;
            RepuestosAutorizado = decimal.Zero;
            RepuestosOriginal = decimal.Zero;
            TapiceriaAutorizado = decimal.Zero;
            TapiceriaOriginal = decimal.Zero;
            LustreOriginal = decimal.Zero;
            LustreAutorizado = decimal.Zero;
            ArmadoOriginal = decimal.Zero;
            ArmadoAutorizado = decimal.Zero;
            DesarmadoAutorizado = decimal.Zero;
            DesarmadoOriginal = decimal.Zero;
            ElectronicaAutorizado = decimal.Zero;
            ElectronicaOriginal = decimal.Zero;
            TotalAutorizado = decimal.Zero;
            TotalOriginal = decimal.Zero;
            ReparacionPlasticosPorcentaje = decimal.Zero;
            DespegadoYPegadoDeCristalesPorcentaje = decimal.Zero;
            MecanicaPorcentaje = decimal.Zero;
            MecanicaTrenDelanteroPorcentaje = decimal.Zero;
            AireAcondicionadoPorcentaje = decimal.Zero;
            TapiceriaPorcentaje = decimal.Zero;
            CerrajeriaPorcentaje = decimal.Zero;
            ElectricidadPorcentaje = decimal.Zero;
            RepuestosPorcentaje = decimal.Zero;
            ElectronicaPorcentaje = decimal.Zero;
            IVAPresupuesto = 0;
            FechaFacturacion = Parametros.FechaMinima;
            FechaEntregaEstimada = null;
            FechaEntregaReal = null;
            NumeroDeSiniestro = "";
            EmpleadoChaperiaId = -1;
            EmpleadoPinturaId = -1;
            RepuestosACargoDeLaCompaniaDeSeguros = false;
            DespegadoYPegadoDeMoldurasEInsigniasAutorizado = decimal.Zero;
            DespegadoYPegadoDeMoldurasEInsigniasOriginal = decimal.Zero;
            AnoVehiculo = "";
            FacturaDeVenta = "";
            FacturaRepuestos = "";
            TipoFacturacion = "";
            FranquiciaOriginal = Decimal.Zero;
            FranquiciaAutorizado = Decimal.Zero;
            PresupuestoOriginalId = -1;
            NumeroDeFactura = "";
            NumeroReciboTransferencia = "";
            AseguradoraId = -1;


        }

        public static ONPresupuesto CrearPresupuesto()
        {
            ONPresupuesto _presupuesto = new ONPresupuesto();
            return _presupuesto;
        }
        public static ONPresupuesto CrearPresupuesto(int pID)
        {
            ONPresupuesto _presupuesto = ObtenerPorID(pID);
            return _presupuesto;
        }
        public ONPresupuesto Insertar()
        {
            return InsertarDAL(Nombre, Apellido, CUIT, CelularTelefono, ProveedorDeRepuestos, FechaPresupuesto, Modelo, Marca, Patente, Inspector, ProveedorDeRepuestos, TipologiaDeAutoNombre, TipologiaDeAutoCoeficiente, CostoDePano, Estado, FechaHoraUltimaActualizacion, FechaHoraCreacion, Observaciones, AireAcondicionadoAutorizado, AireAcondicionadoOriginal, CerrajeriaAutorizado, CerrajeriaOriginal, ChaperiaAutorizado, ChaperiaOriginal, DespegadoYPegadoDeCristalesOriginal, DespegadoYPegadoDeCristalesAutorizado, ElectricidadOriginal, ElectricidadAutorizado, EnceradoAutorizado, EnceradoOriginal, MecanicaAutorizado, MecanicaOriginal, MecanicaTrenDelanteroAutorizado, MecanicaTrenDelanteroOriginal, PinturaOriginal, PinturaAutorizado, ReparacionPlasticosOriginal, ReparacionPlasticosAutorizado, RepuestosOriginal, RepuestosAutorizado, TapiceriaOriginal, TapiceriaAutorizado, LustreOriginal, LustreAutorizado, ArmadoOriginal, ArmadoAutorizado, DesarmadoOriginal, DesarmadoAutorizado, ElectronicaOriginal, ElectronicaAutorizado, NumeroDeChasis, TotalOriginal, TotalAutorizado, IVA, ReparacionPlasticosPorcentaje, DespegadoYPegadoDeCristalesPorcentaje, MecanicaPorcentaje, MecanicaTrenDelanteroPorcentaje, AireAcondicionadoPorcentaje, TapiceriaPorcentaje, CerrajeriaPorcentaje, ElectricidadPorcentaje, RepuestosPorcentaje, ElectronicaPorcentaje, IVAPresupuesto, FechaFacturacion, FechaEntregaEstimada, FechaEntregaReal, NumeroDeSiniestro, EmpleadoChaperiaId, EmpleadoPinturaId, RepuestosACargoDeLaCompaniaDeSeguros, DespegadoYPegadoDeMoldurasEInsigniasOriginal, DespegadoYPegadoDeMoldurasEInsigniasAutorizado, OtrosOriginal, OtrosAutorizado, FechaIngreso, CreadoPor, UltimaModificacionPor, AnoVehiculo, FacturaRepuestos, FacturaDeVenta, TipoFacturacion, FranquiciaOriginal, FranquiciaAutorizado, PresupuestoOriginalId, NumeroDeFactura, NumeroReciboTransferencia, AseguradoraId, UsuarioResponsableId);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(Nombre, Apellido, CUIT, CelularTelefono, FechaPresupuesto, Modelo, Marca, Patente, Inspector, ProveedorDeRepuestos, TipologiaDeAutoNombre, TipologiaDeAutoCoeficiente, CostoDePano, Estado, Observaciones, AireAcondicionadoAutorizado, AireAcondicionadoOriginal, CerrajeriaAutorizado, CerrajeriaOriginal, ChaperiaAutorizado, ChaperiaOriginal, DespegadoYPegadoDeCristalesOriginal, DespegadoYPegadoDeCristalesAutorizado, ElectricidadOriginal, ElectricidadAutorizado, EnceradoAutorizado, EnceradoOriginal, MecanicaAutorizado, MecanicaOriginal, MecanicaTrenDelanteroAutorizado, MecanicaTrenDelanteroOriginal, PinturaOriginal, PinturaAutorizado, ReparacionPlasticosOriginal, ReparacionPlasticosAutorizado, RepuestosOriginal, RepuestosAutorizado, TapiceriaOriginal, TapiceriaAutorizado, LustreOriginal, LustreAutorizado, ArmadoOriginal, ArmadoAutorizado, DesarmadoOriginal, DesarmadoAutorizado, ElectronicaOriginal, ElectronicaAutorizado, NumeroDeChasis, TotalOriginal, TotalAutorizado, IVA, ReparacionPlasticosPorcentaje, DespegadoYPegadoDeCristalesPorcentaje, MecanicaPorcentaje, MecanicaTrenDelanteroPorcentaje, AireAcondicionadoPorcentaje, TapiceriaPorcentaje, CerrajeriaPorcentaje, ElectricidadPorcentaje, RepuestosPorcentaje, ElectronicaPorcentaje, IVAPresupuesto, FechaFacturacion, FechaEntregaEstimada, FechaEntregaReal, NumeroDeSiniestro, EmpleadoChaperiaId, EmpleadoPinturaId, RepuestosACargoDeLaCompaniaDeSeguros, DespegadoYPegadoDeMoldurasEInsigniasOriginal, DespegadoYPegadoDeMoldurasEInsigniasAutorizado, FechaHoraCreacion, OtrosOriginal, OtrosAutorizado, FechaIngreso, UltimaModificacionPor,AnoVehiculo, FacturaRepuestos, FacturaDeVenta, TipoFacturacion, FranquiciaOriginal, FranquiciaAutorizado, PresupuestoOriginalId, NumeroDeFactura, NumeroReciboTransferencia, AseguradoraId, UsuarioResponsableId, ID);
        }
        /// <summary>
        /// Elimina definitivamente el presupuesto y todos los objetos relacionados.
        /// </summary>
        public static void Eliminar(int pID)
        {
            if (pID > 0)
            {
                //elimino los elementos del presupuesto.
                ONElemento.Eliminar(pID);

                //elimino las alarmas del presupuesto.
                ONPresupuestoAlarma.EliminarPorPresupuesto(pID);

                //elimino el presupuesto
                Adaptador.Eliminar(pID);                
            }            
        }
        /// <summary>
        /// Devuelve un duplicado del presupuesto enviado.
        /// Copia solo Resumen menos Aseguradora, Inspector y Siniestro
        /// </summary>
        /// <param name="pPresupuesto"></param>
        /// <returns></returns>
        public static ONPresupuesto CrearDuplicado(ONPresupuesto pPresupuesto)
        {
            ONPresupuesto _presupuesto = new ONPresupuesto();
            _presupuesto.Apellido = pPresupuesto.Apellido;
            _presupuesto.Nombre = pPresupuesto.Nombre;
            _presupuesto.CelularTelefono = pPresupuesto.CelularTelefono;
            _presupuesto.Marca = pPresupuesto.Marca;
            _presupuesto.Modelo = pPresupuesto.Modelo;
            _presupuesto.AnoVehiculo = pPresupuesto.AnoVehiculo;
            _presupuesto.Patente = pPresupuesto.Patente;
            _presupuesto.FechaHoraCreacion = pPresupuesto.FechaHoraCreacion;
            _presupuesto.FechaIngreso = pPresupuesto.FechaIngreso;
            _presupuesto.FechaEntregaEstimada = pPresupuesto.FechaEntregaEstimada;
            _presupuesto.TipologiaDeAutoNombre = pPresupuesto.TipologiaDeAutoNombre;
            _presupuesto.NumeroDeChasis = pPresupuesto.NumeroDeChasis;
            //_presupuesto.Estado = pPresupuesto.Estado;
            _presupuesto.Estado = enuEstados.Borrador.ToString();
            _presupuesto.FacturaRepuestos = pPresupuesto.FacturaRepuestos;
            _presupuesto = _presupuesto.Insertar();

            foreach (ONElemento _elemento in pPresupuesto.TodosLosElementos)
            {
                ONElemento __elemento = _elemento;
                __elemento.IdPresupuesto = _presupuesto.ID;
                __elemento.Controlar = false;
                __elemento.Pintar = false;
                __elemento.SacarColocar = false;
                __elemento.Reacondicionar = false;
                __elemento.Reponer = false;
                __elemento.PintarCantidad = decimal.Zero;
                __elemento.ReponerCantidad = decimal.Zero;
                __elemento.ReacondicionarCantidad = 0;
                __elemento.Insertar();
            }

            return _presupuesto;
        }
        /// <summary>
        /// Crea un duplicado completo del presupuesto copiando todos los datos incluso los elementos.
        /// Utilizado para crear copias cuando se cambia de estado a Reparación y se quiere dejar una copia del presupuesto original
        /// Crea una asociación con el presupuesto original.
        /// NOTA: al hacer el duplicado, el objeto original es modificado por el nuevo en la asignaciòn y modifica el objeto fuera del metodo(objeto pasado como parametro)
        /// </summary>
        /// <param name="pPresupuesto"></param>
        /// <returns>Devuelve el presupuesto copiado.</returns>
        public static ONPresupuesto CrearDuplicadoCompleto(ONPresupuesto pPresupuesto)
        {
            ONPresupuesto _presupuesto = new ONPresupuesto();
            ONElementoColeccion _elementosOriginales = pPresupuesto.TodosLosElementos;
            _presupuesto = pPresupuesto; //copio los datos del resumen
            _presupuesto = _presupuesto.Insertar();

            foreach (ONElemento _elemento in _elementosOriginales)
            { // copio los elementos.
                ONElemento __elemento = _elemento;
                __elemento.IdPresupuesto = _presupuesto.ID;
                __elemento.Insertar();
            }
            return _presupuesto;
        }
        /// <summary>
        /// Calcula el subtotal dependiendo de la franquicia y del tipo de facturacion
        /// </summary>
        /// <param name="pSubtotal"></param>
        /// <param name="pFranquicia"></param>
        /// <param name="pTipoFacturacion"></param>
        /// <returns></returns>
        public static decimal CalcularSubTotalConFranquicia(decimal pSubtotal, decimal pFranquicia, string pTipoFacturacion)
        {
            decimal _resultado = pSubtotal;
            if (pTipoFacturacion == "C")
            {
                // el valor de la franquicia se resta del subtotal
                _resultado = pSubtotal - pFranquicia;
            }
            else
            {
                // el valor de la franquicia no se resta del subtotal
                
            }
            return _resultado;
        }
        /// <summary>
        /// Asigna el producto al presupuesto y realiza todas las tareas asociadas(movimientos de stock)
        /// </summary>
        /// <param name="pIdPresupuesto"></param>
        /// <param name="pIdProducto"></param>
        /// <param name="pIdElemento"></param>
        /// <param name="pCantidad"></param>
        /// <param name="pEstaEnDeposito"></param>
        /// <param name="pResponsable"></param>
        public static StockProductoEnPresupuesto AsignarRepuestoAPresupuesto(int pIdProducto, int pIdElemento, int pCantidad, bool pProductoEstaEnDeposito, string pResponsable)
        {
            
            // Crear movimiento de stock por la cantidad del producto
            //     obtengo el presupuesto para sacar la patente y meterla en las observaciones
            ONElemento _elemento = ONElemento.CrearElemento(pIdElemento);
            ONPresupuesto _presupuesto = ONPresupuesto.CrearPresupuesto(_elemento.IdPresupuesto);
            int _idMovimientoStock = StockMovimientoStock.GenerarMovimientoDeStockConDiferencia("Asignado a " + _presupuesto.Patente, pResponsable, -1 * pCantidad, pIdProducto, pProductoEstaEnDeposito);
            
            // Crear el ProductoEnPresupuesto asociando Elemento y MoviminentoDeStock
            StockProductoEnPresupuesto _productoEnPresupuesto = new StockProductoEnPresupuesto();
            _productoEnPresupuesto.IdMovimientoDeStock = _idMovimientoStock;
            _productoEnPresupuesto.Cantidad = pCantidad;
            //    obtengo el producto asociado para sacarle el nombre
            StockMovimientoStock _movimientoAsociado = StockMovimientoStock.CrearStockMovimientoStock(_idMovimientoStock);
            StockProducto _producto = StockProducto.CrearStockProducto(_movimientoAsociado.IdProducto);
            _productoEnPresupuesto.ProductoNombre = _producto.Nombre;
            _productoEnPresupuesto.PrecioCosto = _producto.PrecioCosto;

            //Genero el precio: si viene del elemento, se pone el precio del elemento, de lo contrario se calcula como la cantidad x el precio de venta +iva si tiene
            decimal _precioDeVenta;
            if (_elemento.ReponerCantidad > decimal.Zero)
                _precioDeVenta = _elemento.ReponerCantidad;
            else
            {//calculo el precio de venta por el precio de venta del producto * cantidad + IVA si corresponde
                _precioDeVenta = _producto.PrecioVenta * pCantidad;
                if (_producto.IVA > decimal.Zero)//le agrego el iva
                    _precioDeVenta = _precioDeVenta + _precioDeVenta * (_producto.IVA / 100);
            }
            _productoEnPresupuesto.PrecioVenta = _precioDeVenta; 
            _productoEnPresupuesto.ProductoProvistoPorElTaller = true;
            _productoEnPresupuesto.IdElemento = pIdElemento;
            return _productoEnPresupuesto.Insertar();
        }
        /// <summary>
        /// Libera el repuesto del presupuesto realizando las siguientes tareas:
        /// - Generar un movimiento de stock inverso para dar de alta el stock asignado.
        /// - Eliminar la asociación de pIdProductoEnPresupuesto
        /// </summary>
        /// <param name="pIdProductoEnPresupuesto"></param>
        public static void LiberarRepuestoDePresupuesto(int pIdProductoEnPresupuesto, string pResponsable)
        {
            // Primero genero el movimiento de stock inverso
            StockProductoEnPresupuesto _spep = StockProductoEnPresupuesto.CrearStockProductoEnPresupuesto(pIdProductoEnPresupuesto);
            StockMovimientoStock.GenerarMovimientoDeStockConDiferencia("Liberación de: '" + _spep.MovimientoAsociado.Observaciones + "'", pResponsable, _spep.Cantidad, _spep.IdProducto, _spep.ProductoEnDeposito);
            
            // elimino la asociación
            StockProductoEnPresupuesto.Eliminar(pIdProductoEnPresupuesto);
        }
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONPresupuesto pPresupuesto)
        {
            if (pPresupuesto != null)
                pPresupuesto.Actualizar();
        }
        public ONPresupuesto Insertar(ONPresupuesto pPresupuesto)
        {
            if (pPresupuesto != null)
                return pPresupuesto.Insertar();
            return null;
        }
        public void Eliminar(ONPresupuesto pPresupuesto)
        {
            ONPresupuesto.Eliminar(pPresupuesto.ID);
            pPresupuesto = null;
        }
        #endregion
    }

    [Serializable]
    [System.ComponentModel.DataObject]
    public class ONPresupuestoColeccion : System.Collections.CollectionBase
    {
        public void AgregarAColeccion(ONPresupuesto pPresupuesto)
        {
            //verifico que no lo haya ingresado anteriormente. Si esta repetido, lo salta
            foreach (ONPresupuesto _presupuesto in this)
                if (_presupuesto.ID == pPresupuesto.ID)
                    return;

            this.List.Add(pPresupuesto);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONPresupuesto pPresupuesto)
        {
            for(int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pPresupuesto.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public ONPresupuesto this[int index]
        {
            get { return ((ONPresupuesto)(this.List[index])); }
            set { this.List[index] = value; }
        }
        
        #region Para datasource
        public static ONPresupuestoColeccion ObtenerPresupuestoPorID(int pID)
        {
            ONPresupuestoColeccion _resultado = null;
            ONPresupuesto _presupuesto = ONPresupuesto.CrearPresupuesto(pID);
            if (_presupuesto != null)
            {
                _resultado = new ONPresupuestoColeccion();
                _resultado.AgregarAColeccion(_presupuesto);
            }

            return _resultado;
        }
        public static ONPresupuestoColeccion ObtenerPor(string pDesde, string pHasta, string pTexto, string pEstado)
        {
            return ONPresupuesto.ObtenerPor(pDesde, pHasta, pTexto, pEstado);
        }
        #endregion
    }
}
